@aalis/plugin-llm-ollama 0.13.0 → 0.14.1

package/dist/index.js

@@ -1,10 +1,13 @@
-import { LLMCapabilities, llm, metered, requestedThinking } from '@aalis/api-llm';
+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 } 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。
@@ -119,68 +119,75 @@ export async function readBodyCapped(res, maxBytes) {
 }
 /** 报告了思考能力的模型允许的档位：开关型，翻成 think 开关 */
 const THINKING_LEVELS = [
-    { id: 'off', label: '关' },
-    { id: 'on', label: '开' },
+    { 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: 'select',
-        label: '默认思考档位',
+        label: t('thinkingLabel'),
         default: 'on',
         options: THINKING_LEVELS.map(level => ({ label: level.label, value: level.id })),
-        description: '报告了思考能力的模型（或单模型能力覆盖里写了 thinking 的）在请求没指定档位时用这一档，会话设置的「深度思考」压过它。' +
-            '没有思考能力的模型不发 think 参数。',
+        description: t('thinkingDescription'),
     },
 });
 /**
@@ -245,6 +252,7 @@ function extractThinkTags(text) {
 }
 // ===== Ollama 客户端（共享底层 fetch 封装，多个 ModelHandle 复用） =====
 class OllamaClient {
+    activation;
     baseUrl;
     timeout;
     temperature;
@@ -253,10 +261,16 @@ class OllamaClient {
     keepAlive;
     logger;
     proc;
-    constructor(config, logger, proc) {
+    /**
+     * 生成请求的连接池：不设等响应头与读响应体的时限（默认各 300 秒），timeout 是唯一的时限。dispatcher 是 Node 自带 fetch
+     * 认的扩展字段，DOM 的 RequestInit 里没有（测试的类型检查带 DOM），带它的选项按 RequestInit 断言
+     */
+    dispatcher = new Agent({ headersTimeout: 0, bodyTimeout: 0 });
+    constructor(config, logger, proc, activation) {
+        this.activation = activation;
         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;
@@ -264,25 +278,48 @@ class OllamaClient {
         this.logger = logger;
         this.proc = proc;
     }
+    /**
+     * 停用时关掉生成请求的连接池。在飞的请求不用等：它们的信号合着本插件这次激活的（见 signalOf），停用开始时已经中止；
+     * 停用之后发来的请求由入口的 refuseIfClosed 拒绝（报插件已停用或重载）
+     */
+    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));
+    }
+    /** 本插件已停用或重载（停用之后还拿着旧句柄发来的请求）：不发，报插件已停用或重载、这次请求没有发出 */
+    refuseIfClosed() {
+        if (this.activation.aborted)
+            throw new TextError(t('pluginClosed'));
+    }
+    /** 这次请求的中止信号：调用方的与本插件这次激活的合起来，调用方没中止、本插件停用或重载时请求同样停下 */
+    signalOf(request) {
+        return request.signal ? AbortSignal.any([request.signal, this.activation]) : this.activation;
+    }
+    /** 这次请求已中止时抛出：调用方中止的抛它的中止原因，本插件停用或重载的报中途停下 */
+    throwIfAborted(request) {
+        request.signal?.throwIfAborted();
+        if (this.activation.aborted)
+            throw new TextError(t('pluginStopped'));
     }
     /**
-     * 对话请求没拿到完整应答（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)}`);
+        if (this.activation.aborted)
+            return new TextError(t('pluginStopped'));
+        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`);
-        }
-        if (err instanceof TypeError && err.message === 'fetch failed') {
-            return new Error('Ollama 连不上服务：检查 baseUrl 与网络，详情见日志');
+            return new TextError(t('requestTimeout', { seconds: this.timeout / 1000 }));
         }
+        if (err instanceof TypeError && err.message === 'fetch failed')
+            return new TextError(t('unreachable'));
         return err;
     }
     /** 对话应答按 JSON 解析；不是 JSON 时截断后的应答体记 warn，抛出一行说明 */
@@ -292,7 +329,7 @@ class OllamaClient {
         }
         catch {
             this.logger.warn(`Ollama 应答不是 JSON (${status}): ${bodyExcerpt(text)}`);
-            throw new Error(`Ollama 应答不是 JSON (${status})；详情见日志`);
+            throw new TextError(t('notJson', { status }));
         }
     }
     /**
@@ -319,17 +356,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 });
         }
     }
     /**
@@ -360,7 +397,7 @@ class OllamaClient {
      * [系统通知]/[跨会话委派] 等前缀。level 是这次的思考档位，不能调的模型没有
      */
     async buildRequestBody(model, request, level, stream) {
-        const messages = await Promise.all(prepareLLMMessages(request.messages).map(m => this.toOllamaMessage(m, request.requireImages === true)));
+        const messages = await Promise.all(prepareLLMMessages(request.messages).map(m => this.toOllamaMessage(m, request)));
         const tools = request.tools?.map(t => this.toOllamaTool(t));
         const body = {
             model,
@@ -382,15 +419,13 @@ class OllamaClient {
         return { body, messages, tools };
     }
     async chat(model, request, level) {
+        this.refuseIfClosed();
         // 包含音频输入 → 改走 OpenAI 兼容的 /v1/chat/completions（/api/chat 不支持 audios）
         if (request.messages.some(m => m.audios && m.audios.length > 0)) {
             return this.chatOpenAIWithAudio(model, request, level);
         }
         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 signals = [AbortSignal.timeout(this.timeout)];
-        if (request.signal)
-            signals.push(request.signal);
         const startedAt = Date.now();
         let response;
         let text;
@@ -399,7 +434,8 @@ class OllamaClient {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(body),
-                signal: AbortSignal.any(signals),
+                signal: idleTimeout(this.timeout, this.signalOf(request)).signal,
+                dispatcher: this.dispatcher,
             });
             text = await response.text();
         }
@@ -409,14 +445,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)
@@ -433,6 +470,7 @@ class OllamaClient {
         return result;
     }
     async *chatStream(model, request, level) {
+        this.refuseIfClosed();
         // 包含音频输入 → 回退为非流式（OpenAI compat 路径不支持 SSE 交互）后以单 chunk 交付。
         if (request.messages.some(m => m.audios && m.audios.length > 0)) {
             const r = await this.chatOpenAIWithAudio(model, request, level);
@@ -441,14 +479,25 @@ class OllamaClient {
                 reasoningDelta: r.reasoningContent ?? '',
                 usage: r.usage,
                 done: true,
+                finishReason: r.finishReason,
             };
             return;
         }
         const { body, messages } = await this.buildRequestBody(model, request, level, true);
         this.logger.debug(`流式请求 Ollama${level ? ` (思考 ${level})` : ''}: ${body.model}, ${messages.length} 条消息`);
-        const signals = [AbortSignal.timeout(this.timeout)];
-        if (request.signal)
-            signals.push(request.signal);
+        // 交出一段期间不计时：调用方处理一段的时间不算停顿
+        const timer = idleTimeout(this.timeout, this.signalOf(request));
+        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)`);
@@ -459,7 +508,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) {
@@ -475,7 +525,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();
@@ -510,6 +560,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);
@@ -536,7 +589,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;
@@ -552,11 +605,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 = '';
@@ -629,8 +686,8 @@ class OllamaClient {
         finally {
             clearTimeout(streamStallTimer);
             // cancel 而非仅 releaseLock：中止/提前退出时要主动关闭响应体。releaseLock 只是放锁，
-            // 底层流仍开着——被打断的生成会让 undici 挂着半读的响应与套接字，直到请求超时兜底
-            // 才释放（本地慢生成 + lane 中止高频后，这类残留一挂就是整个超时窗）。
+            // 底层流仍开着——被打断的生成会让 undici 一直持有半读的响应与套接字，直到请求超时兜底
+            // 才释放（本地慢生成时回合常被停下，这类残留一挂就是整个超时窗）。
             // cancel 自带放锁。三条退出路径的语义：读尽 EOF（done:true）→ 流已 closed，cancel 是
             // 真 no-op；收到终帧即 return（未读到 EOF）与消费方提前 break → cancel 中止残余响应体，
             // 这正是本修复要的「立即交还套接字」，代价是该连接不回 keep-alive 池。
@@ -648,19 +705,22 @@ class OllamaClient {
      * 支持 data URI、HTTP(S) URL、纯 base64、文件路径。返回 null 表示图片无法获取。
      * 所有返回都会去除空白字符（Ollama 校验时不容忍 base64 内的换行/空格，
      * 否则会返回 `illegal base64 data at input byte N` 错误）。
+     * 网址的下载随这次请求的中止信号（见 signalOf）停下，中止时按 throwIfAborted 抛出。
      */
-    async resolveImage(img) {
+    async resolveImage(img, request) {
         const sanitize = (b64) => b64.replace(/[\s\r\n]+/g, '');
         const trimmed = img.trim();
         // data URI → 提取 base64（兼容多参数格式如 data:image/png;charset=utf-8;base64,...）
         const dataMatch = trimmed.match(/^data:[^,]*;base64,(.+)$/);
         if (dataMatch)
             return sanitize(dataMatch[1]);
-        // HTTP(S) URL → 下载并转 base64（流式限额：超限即断，防超大/恶意资源撑爆内存——
+        // HTTP(S) URL → 下载并转 base64（流式限额：超限即断，防超大/恶意资源耗尽内存——
         // 附件缓存侧有 maxBytes 上限，但缓存失败回退原 URL 时会走到这里，此前这一侧不限量）
         if (/^https?:\/\//i.test(trimmed)) {
             try {
-                const res = await safeFetch(trimmed, { signal: AbortSignal.timeout(30000) });
+                const res = await safeFetch(trimmed, {
+                    signal: AbortSignal.any([AbortSignal.timeout(30000), this.signalOf(request)]),
+                });
                 if (!res.ok) {
                     this.logger.warn(`下载图片失败 (${res.status}): ${trimmed}`);
                     return null;
@@ -673,6 +733,8 @@ class OllamaClient {
                 return buf.toString('base64');
             }
             catch (err) {
+                // 中止不是图片取不到：这次调用随之停下
+                this.throwIfAborted(request);
                 this.logger.warn(`下载图片异常: ${trimmed}`, err);
                 return null;
             }
@@ -699,15 +761,15 @@ class OllamaClient {
      * `requireImages` 为真时一张都拿不到就抛：视觉识别这类调用里图片就是全部内容，
      * 省掉它降级成纯文本，模型只看得到 prompt 里的占位文字，会照着编出一段描述，
      * 而调用方拿到非空内容便记成识别成功——失败被伪装成幻觉，比报错难查得多。
-     * 为假时（顺手带图）保持宽松，warn 后按剩余的继续，不打断这一轮。
+     * 为假时（同时带图）保持宽松，warn 后按剩余的继续，不打断这一轮。
      */
-    async resolveImages(images, requireImages) {
-        const resolved = await Promise.all(images.map(img => this.resolveImage(img)));
+    async resolveImages(images, request) {
+        const resolved = await Promise.all(images.map(img => this.resolveImage(img, request)));
         const valid = resolved.filter((r) => r !== null);
         if (valid.length === images.length)
             return valid;
-        if (valid.length === 0 && requireImages) {
-            throw new Error(`图片全部获取失败（共 ${images.length} 张），拒绝降级为纯文本请求`);
+        if (valid.length === 0 && request.requireImages === true) {
+            throw new TextError(t('imagesUnavailable', { count: images.length }));
         }
         this.logger.warn(`图片获取失败 ${images.length - valid.length}/${images.length} 张，按剩余的继续`);
         return valid;
@@ -717,7 +779,7 @@ class OllamaClient {
      * Ollama 的图片通过 images 字段传递 base64 数据（或 URL）
      * 工具调用结果通过 role: tool 传递
      */
-    async toOllamaMessage(msg, requireImages = false) {
+    async toOllamaMessage(msg, request) {
         // 调用方已经 prepareLLMMessages 处理过：role 已是 WellKnownRole，自定义 role / kind
         // 对应的前缀已拼接进 content。这里只需透传。
         const ollamaMsg = {
@@ -730,7 +792,7 @@ class OllamaClient {
         }
         // 多模态：Ollama 支持 images 字段（base64 或文件路径）
         if (msg.images && msg.images.length > 0 && msg.role === 'user') {
-            const valid = await this.resolveImages(msg.images, requireImages);
+            const valid = await this.resolveImages(msg.images, request);
             if (valid.length > 0)
                 ollamaMsg.images = valid;
         }
@@ -768,7 +830,7 @@ class OllamaClient {
             // Modality order：Ollama 官方 best practice 要求 image/audio content
             // 必须在 text 之前。
             if (m.images && m.images.length > 0 && m.role === 'user') {
-                for (const b64 of await this.resolveImages(m.images, request.requireImages === true)) {
+                for (const b64 of await this.resolveImages(m.images, request)) {
                     blocks.push({ type: 'image_url', image_url: { url: `data:image/png;base64,${b64}` } });
                 }
             }
@@ -814,9 +876,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;
@@ -825,7 +884,8 @@ class OllamaClient {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(body),
-                signal: AbortSignal.any(signals),
+                signal: idleTimeout(this.timeout, this.signalOf(request)).signal,
+                dispatcher: this.dispatcher,
             });
             respText = await resp.text();
         }
@@ -834,30 +894,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,
@@ -868,32 +923,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 {
@@ -1106,11 +1159,11 @@ async function start({ config, logger, lifecycle, provide, events, proc }) {
     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.use, proc.use);
+    const client = new OllamaClient(cfg, logger.use, proc.use, lifecycle.use.signal);
+    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。关闭模型发现时不提供：没有可重新发现的列表
@@ -1160,7 +1213,7 @@ async function start({ config, logger, lifecycle, provide, events, proc }) {
     let discoveryError;
     const remoteIds = cfg.discoverModels
         ? await client.fetchRemoteModelIds(lifecycle.use.signal).catch((err) => {
-            discoveryError = err instanceof Error ? err.message : String(err);
+            discoveryError = textOf(err);
             return [];
         })
         : [];
@@ -1170,11 +1223,11 @@ async function start({ config, logger, lifecycle, provide, events, proc }) {
     // 提示写在原因之前：原因里可能带着一段响应体
     if (initialIds.length === 0) {
         throw configError(discoveryError
-            ? `取不到 Ollama 的模型列表，没有可注册的模型：确认 Ollama 在运行、baseUrl 写对后重载本插件，或在 customModels 里写明要用的模型。原因：${discoveryError}`
-            : `Ollama 已连接 ${shownBaseUrl}，但未发现任何可用模型；先用 ollama pull 下载模型，或在 customModels 里写明要用的模型`);
+            ? t('noModelsDiscoveryFailed', { error: discoveryError })
+            : t('noModels', { baseUrl: cfg.baseUrl }));
     }
     if (discoveryError)
-        logger.use.warn(`启动时只注册 customModels 里的模型；${discoveryError}`);
+        logger.use.warn(`启动时只注册 customModels 里的模型；${toSource(discoveryError)}`);
     // 并行查每个模型的真实能力(顺序保留→注册顺序稳定→优先级稳定);失败者回退家族表。
     const detectedCaps = await Promise.all(initialIds.map(id => client.fetchModelCapabilities(id, lifecycle.use.signal)));
     lifecycle.use.signal.throwIfAborted();
@@ -1182,13 +1235,13 @@ async function start({ config, logger, lifecycle, provide, events, proc }) {
         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.use.info(!cfg.discoverModels
-        ? `Ollama 未开启模型发现: ${shownBaseUrl}，注册 customModels 里的 ${registered.size} 个 model entry`
+        ? `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 据此报错）、不增删条目：按空列表处理会把自动发现的