my-ai-chat-framework 2.7.0 → 3.0.0

package/dist/my-ai-chat-framework.browser.umd.js

@@ -143,6 +143,25 @@
 			return [];
 		}
 		/**
+		* 撤回到指定消息 id 的上一个用户消息，删除两者之间的所有消息
+		* 适用于重发
+		* @param {string} id — 目标消息 id
+		* @returns {Array} 被删除的消息列表
+		*/
+		undoToPreviousUser(id) {
+			let targetIndex = -1;
+			let previousUserIndex = -1;
+			for (let i = this._messages.length - 1; i >= 0; i--) {
+				if (this._messages[i].id === id) targetIndex = i;
+				if (targetIndex >= 0 && this._messages[i].role === "user") {
+					previousUserIndex = i;
+					break;
+				}
+			}
+			if (targetIndex >= 0 && previousUserIndex >= 0) return this._messages.splice(previousUserIndex + 1, targetIndex - previousUserIndex);
+			return [];
+		}
+		/**
 		* 更新消息：按 id 查找并合并 changes，不新增消息
 		* @param {string} id — 消息 id
 		* @param {Object} changes — 要合并的字段
@@ -312,7 +331,85 @@
 		}
 	};
 	//#endregion
+	//#region src/core/Pipeline.js
+	/**
+	* Pipeline —— 极简顺序管道（v3.0 提案 · 阶段 1）
+	*
+	* 三个概念（对照 pipeline-demo.html）：
+	* - 小车 ctx   —— 本次请求的全部"状态"，车间之间只通过它交接
+	* - 车间 stage —— { name, run(ctx) }，只干一件事，不认别的车间
+	* - 调度 run()  —— for + await，顺序执行（线性，无"回程"；洋葱能力留给阶段 2 的 after 车间）
+	*/
+	var Pipeline = class {
+		constructor() {
+			this._stages = [];
+		}
+		/**
+		* 注册一个车间（追加到末尾）。
+		* @param {{name: string, run: (ctx: object) => void | Promise<void>}} stage
+		* @returns {Pipeline} this，支持链式
+		*/
+		register(stage) {
+			if (!stage || typeof stage.run !== "function") throw new TypeError("Pipeline.register: stage 需要 { name, run(ctx) }，运行 run 必须是函数");
+			this._stages.push(stage);
+			return this;
+		}
+		/** 按名字移除车间（移除不存在的名字是安全的） */
+		unregister(name) {
+			this._stages = this._stages.filter((s) => s.name !== name);
+			return this;
+		}
+		/** 列出当前车间名（调试用） */
+		names() {
+			return this._stages.map((s) => s.name);
+		}
+		/** 把小车开过所有车间；返回 ctx（车间可改 ctx 上的字段） */
+		async run(ctx) {
+			for (const stage of this._stages) await stage.run(ctx);
+			return ctx;
+		}
+	};
+	//#endregion
 	//#region src/core/ChatService.js
+	/**
+	* @typedef {Object} ChatAdapter 适配器协议（v3.0：写同级适配器只需实现这 4+1 个方法）
+	* @property {Function} buildRequest  (messages, config, systemPrompts) => requestBody
+	* @property {Function} send          (body, config, opts) => Promise<apiResponse>
+	* @property {Function} stream        (body, config, onProgress, onDone, opts) => Promise<void>
+	* @property {Function} parseResponse (apiResponse) => assistantMessage
+	* @property {Function} [getRequestDefaults] () => 默认请求参数（可选）
+	* @property {Function} [install]     (chatService, options) 插件式安装（可选）
+	*/
+	/**
+	* @typedef {Object} PipelineContext 管道小车 ctx（public pipe 车间可见/可改的全部字段）
+	* @property {Object}   options       原始请求选项
+	* @property {*}        userInput     用户输入（可为 undefined）
+	* @property {boolean}  addUser       是否已新增/将新增用户消息
+	* @property {MessageStore} messages  消息列表（可读可改：push / unshift / update）
+	* @property {SystemPromptStore} systemPrompts 系统提示词（可读可改）
+	* @property {Object}   config        合并后的请求级配置（prepareInput 后生效）
+	* @property {boolean}  isStream      本次是否流式
+	* @property {Function|null} onProgress 流式进度回调
+	* @property {Function|null} onDone     流式完成回调
+	* @property {string|null} mergeToEntry 续写目标 id（null = 普通发送）
+	* @property {*}        body          请求体（buildRequest 后产出）
+	* @property {*}        result        最终结果（send 后产出）
+	*/
+	/**
+	* @typedef {Object} PipeStage 车间（v3.0 公开扩展单元）
+	* @property {string}   name      车间名（唯一，不能与内部车间重名）
+	* @property {string}   [phase]   'beforeSend'（默认）| 'afterSend'
+	* @property {Function} run       (ctx: PipelineContext) => void | Promise<void>
+	*/
+	var SESSION_CONFIG_KEYS = [
+		"model",
+		"temperature",
+		"maxTokens",
+		"modelParams",
+		"system",
+		"retry",
+		"ephemeralContinue"
+	];
 	var ChatService = class extends EventEmitter {
 		constructor(config = {}) {
 			super();
@@ -326,17 +423,106 @@
 			this._processResponse = null;
 			const model = this.config.model || this.config.modelParams?.model;
 			if (!model || typeof model !== "string" || !model.trim()) throw new ConfigurationError("缺少 model 配置");
-			const temperature = this.config.modelParams?.temperature ?? this.config.temperature;
+			this._assertValidConfig(this.config);
+			if (typeof config.system === "string" && config.system.trim()) this.systemPrompts.set(config.system);
+			if (config.adapter) this.setAdapter(config.adapter);
+			this._userStages = [];
+			this._pipeline = this._buildPipeline();
+		}
+		/**
+		* 校验配置中的可校验字段（model 必填由构造器负责，这里只校验存在性）
+		* @throws {ConfigurationError}
+		*/
+		_assertValidConfig(cfg) {
+			const temperature = cfg.modelParams?.temperature ?? cfg.temperature;
 			if (temperature !== void 0 && (typeof temperature !== "number" || temperature < 0 || temperature > 2)) throw new ConfigurationError(`temperature 必须在 0-2 之间，当前值: ${temperature}`);
-			const maxTokens = this.config.modelParams?.maxTokens ?? this.config.maxTokens;
+			const maxTokens = cfg.modelParams?.maxTokens ?? cfg.maxTokens;
 			if (maxTokens !== void 0 && (typeof maxTokens !== "number" || maxTokens < 1 || !Number.isInteger(maxTokens))) throw new ConfigurationError(`maxTokens 必须为正整数，当前值: ${maxTokens}`);
-			if (typeof config.system === "string" && config.system.trim()) this.systemPrompts.set(config.system);
+			const model = cfg.model ?? cfg.modelParams?.model;
+			if (model !== void 0 && (typeof model !== "string" || !model.trim())) throw new ConfigurationError("model 必须是非空字符串");
+		}
+		use(plugin, options = {}) {
+			plugin.install(this, options);
+			return this;
 		}
-		use(plugin) {
-			plugin.install(this);
+		/**
+		* 往请求管道里挂一个"车间"。
+		* - phase 'beforeSend'（默认）：在内部 beforeRequest 钩子之后、构建请求体之前执行
+		* - phase 'afterSend'  ：在内部发送（流式/非流式）完成、结果落位之后执行（可改 ctx.result）
+		* 不注册任何车间 = 行为与版本 2.8.x 完全一致。
+		* @param {PipeStage} stage
+		* @returns {ChatService} this
+		* @throws {ConfigurationError} 参数非法 / 名字被占用 / 与内部车间重名
+		*/
+		pipe(stage) {
+			if (!stage || typeof stage !== "object" || typeof stage.run !== "function") throw new ConfigurationError("pipe: 需要 { name, phase?, run(ctx) }，run 必须是函数");
+			if (typeof stage.name !== "string" || !stage.name.trim()) throw new ConfigurationError("pipe: 需要 name（车间名，非空字符串）");
+			if ([
+				"prepareInput",
+				"beforeSend",
+				"autoContinue",
+				"buildRequest",
+				"send"
+			].includes(stage.name)) throw new ConfigurationError(`pipe: "${stage.name}" 是内部车间名，请换一个名字`);
+			if (this._userStages.some((s) => s.name === stage.name)) throw new ConfigurationError(`pipe: 车间 "${stage.name}" 已存在，请先 chat.unpipe("${stage.name}")`);
+			const phase = stage.phase === "afterSend" ? "afterSend" : "beforeSend";
+			this._userStages.push({
+				name: stage.name,
+				phase,
+				run: stage.run
+			});
+			this._rebuildPipeline();
 			return this;
 		}
+		/** 移除一个用户车间（移除不存在的名字是安全的）。@returns {ChatService} this */
+		unpipe(name) {
+			const before = this._userStages.length;
+			this._userStages = this._userStages.filter((s) => s.name !== name);
+			if (this._userStages.length !== before) this._rebuildPipeline();
+			return this;
+		}
+		/** 查看当前管道里所有车间名（调试/说明用，含内部车间） */
+		get pipelineStages() {
+			return this._pipeline.names();
+		}
+		/** 重建内部管道：内部 5 车间 + 用户车间按 phase 插入 */
+		_buildPipeline() {
+			const p = new Pipeline();
+			p.register({
+				name: "prepareInput",
+				run: (ctx) => this._stagePrepareInput(ctx)
+			});
+			p.register({
+				name: "beforeSend",
+				run: (ctx) => this._stageBeforeSend(ctx)
+			});
+			for (const s of this._userStages) if (s.phase === "beforeSend") p.register({
+				name: s.name,
+				run: (ctx) => s.run(ctx)
+			});
+			p.register({
+				name: "autoContinue",
+				run: (ctx) => this._stageAutoContinue(ctx)
+			});
+			p.register({
+				name: "buildRequest",
+				run: (ctx) => this._stageBuildRequest(ctx)
+			});
+			p.register({
+				name: "send",
+				run: (ctx) => this._stageSend(ctx)
+			});
+			for (const s of this._userStages) if (s.phase === "afterSend") p.register({
+				name: s.name,
+				run: (ctx) => s.run(ctx)
+			});
+			return p;
+		}
+		_rebuildPipeline() {
+			this._pipeline = this._buildPipeline();
+		}
 		setAdapter(adapter) {
+			assertAdapter(adapter);
 			this._adapter = adapter;
 		}
 		abort() {
@@ -357,17 +543,24 @@
 				this.messages.update(target.id, {
 					_complete: true,
 					prefix: void 0,
-					_ephemeral: void 0
+					_ephemeral: false
 				});
 				return target;
 			} catch (err) {
-				this.messages.update(target.id, { prefix: void 0 });
+				this.messages.update(target.id, {
+					_complete: true,
+					prefix: void 0,
+					_ephemeral: false
+				});
+				if (err.name === "AbortError") {
+					this.emit("aborted", { timestamp: Date.now() });
+					return target;
+				}
 				throw err;
 			}
 		}
 		async continueLastStream(onProgress, onDone) {
 			const target = this._prepareContinue();
-			console.log("[DEBUG] continueLastStream target.id:", target.id);
 			this.messages.update(target.id, { prefix: true });
 			const baseLen = (target.content || "").length;
 			try {
@@ -388,11 +581,19 @@
 				this.messages.update(target.id, {
 					_complete: true,
 					prefix: void 0,
-					_ephemeral: void 0
+					_ephemeral: false
 				});
 				return target;
 			} catch (err) {
-				this.messages.update(target.id, { prefix: void 0 });
+				this.messages.update(target.id, {
+					_complete: true,
+					prefix: void 0,
+					_ephemeral: false
+				});
+				if (err.name === "AbortError") {
+					this.emit("aborted", { timestamp: Date.now() });
+					return target;
+				}
 				throw err;
 			}
 		}
@@ -402,7 +603,20 @@
 			if (last && (last.role === "assistant" || last._ephemeral)) return last;
 			throw new Error("最后一条消息不是 assistant，无法续写");
 		}
+		/**
+		* 运行时修改配置（仅会话层字段）。
+		*
+		* 白名单：model / temperature / maxTokens / modelParams / system / retry / ephemeralContinue。
+		* - 运输层（apiKey/baseUrl/headers）：归适配器，要改就换适配器实例
+		* - 请求参数默认值：走适配器工厂 options 或请求级覆盖（chat.send(x, params)）
+		* - 能力表：归 modelRegistry 插件
+		*
+		* 与构造器一样经过校验，不能注入非法值。
+		* @throws {ConfigurationError} 非白名单字段或非法值
+		*/
 		updateConfig(partial) {
+			for (const key of Object.keys(partial)) if (!SESSION_CONFIG_KEYS.includes(key)) throw new ConfigurationError(`updateConfig 不支持修改 "${key}"。允许的会话层字段: ${SESSION_CONFIG_KEYS.join(", ")}`);
+			this._assertValidConfig(partial);
 			Object.assign(this.config, partial);
 			if (typeof partial.system === "string") this.systemPrompts.set(partial.system);
 			this.emit("config-updated", {
@@ -410,36 +624,72 @@
 				timestamp: Date.now()
 			});
 		}
-		async _request(options) {
-			let { userInput, addUser = true, isStream = false, onProgress, onDone, mergeToEntry } = options;
-			this.emit("sending", {
-				addUser,
-				userInput,
-				timestamp: Date.now()
-			});
-			this._addUserMessage(userInput, addUser);
-			await this._hooks.emitAsync("beforeRequest", {
-				messages: this.messages,
-				config: this.config,
-				options
-			});
-			if (this.config.ephemeralContinue && !mergeToEntry) {
-				const msgs = this.messages.getAll();
-				const last = msgs[msgs.length - 1];
-				if (last && last.prefix && (last.role === "assistant" || last._ephemeral)) mergeToEntry = last.id;
+		/**
+		* 合并请求参数（近者优先）：
+		*   适配器默认(getRequestDefaults) ← 会话配置(this.config) ← 本次覆盖(params)
+		* modelParams 深层合并；平铺便捷键（temperature/maxTokens/reasoningEffort）自动折叠进 modelParams
+		*/
+		_mergeRequestConfig(params = {}) {
+			const adapterDefaults = this._adapter?.getRequestDefaults?.() || {};
+			const requestConfig = {
+				...adapterDefaults,
+				...this.config,
+				...params
+			};
+			const modelParams = {
+				...adapterDefaults.modelParams || {},
+				...this.config.modelParams || {},
+				...params.modelParams || {}
+			};
+			for (const key of [
+				"temperature",
+				"maxTokens",
+				"reasoningEffort"
+			]) {
+				const value = params[key] ?? this.config[key] ?? adapterDefaults[key];
+				if (value !== void 0) modelParams[key] = value;
 			}
-			const body = this._adapter.buildRequest(this.messages.getAll(), this.config, this.systemPrompts.getEnabled());
-			const retryCfg = this.config.retry || {};
+			requestConfig.modelParams = modelParams;
+			return requestConfig;
+		}
+		/**
+		* 内部调度（v3.0 提案 · 阶段 1）：造一辆小车 ctx，开过内部管道，返回结果。
+		* 行为与旧版 _request 完全一致，只是把固定线拆成了车间（见 _stage* 方法）。
+		*
+		* ctx 字段（车间可见）：
+		*   options       —— 原始请求选项
+		*   userInput     —— 用户输入
+		*   addUser       —— 是否新增用户消息
+		*   messages      —— MessageStore（可读可改）
+		*   systemPrompts —— SystemPromptStore
+		*   config        —— 合并后的请求级配置（prepareInput 车间产出）
+		*   isStream      —— 本次是否流式
+		*   onProgress    —— 流式进度回调（可为 null）
+		*   onDone        —— 流式完成回调（可为 null）
+		*   mergeToEntry  —— 续写目标 id（空 = 普通发送）
+		*   body          —— adapter 构建出的请求体（buildRequest 车间产出）
+		*   result        —— 最终结果（send 车间产出）
+		*/
+		async _request(options = {}) {
+			const ctx = {
+				options,
+				userInput: options.userInput,
+				addUser: options.addUser !== false,
+				messages: this.messages,
+				systemPrompts: this.systemPrompts,
+				config: null,
+				isStream: !!options.isStream,
+				onProgress: options.onProgress || null,
+				onDone: options.onDone || null,
+				mergeToEntry: options.mergeToEntry || null,
+				body: null,
+				result: null
+			};
 			try {
-				return await this._withRetry(body, {
-					isStream,
-					onProgress,
-					onDone,
-					mergeToEntry,
-					maxRetries: retryCfg.maxRetries ?? 0,
-					retryDelay: retryCfg.retryDelay ?? 1e3
-				});
+				await this._pipeline.run(ctx);
+				return ctx.result;
 			} catch (error) {
+				if (error.name === "AbortError") throw error;
 				this.emit("error", {
 					error,
 					timestamp: Date.now()
@@ -447,6 +697,49 @@
 				throw error;
 			}
 		}
+		/** 车间 1：加用户消息 → 合并请求参数 → 广播 sending */
+		async _stagePrepareInput(ctx) {
+			this._addUserMessage(ctx.userInput, ctx.addUser);
+			ctx.config = this._mergeRequestConfig(ctx.options.params);
+			this.emit("sending", {
+				addUser: ctx.addUser,
+				userInput: ctx.userInput,
+				timestamp: Date.now()
+			});
+		}
+		/** 车间 2：发送前钩子（兼容桥：事件钩子照发；阶段 4 会迁到 beforeSend 公开位置） */
+		async _stageBeforeSend(ctx) {
+			await this._hooks.emitAsync("beforeRequest", {
+				messages: ctx.messages,
+				config: ctx.config,
+				options: ctx.options
+			});
+		}
+		/** 车间 3：自动续写检测（ephemeralContinue 时，底部若有 prefix 消息则续写） */
+		async _stageAutoContinue(ctx) {
+			if (this.config.ephemeralContinue && !ctx.mergeToEntry) {
+				const msgs = ctx.messages.getAll();
+				const last = msgs[msgs.length - 1];
+				if (last && last.prefix && (last.role === "assistant" || last._ephemeral)) ctx.mergeToEntry = last.id;
+			}
+		}
+		/** 车间 4：构建请求体 */
+		async _stageBuildRequest(ctx) {
+			ctx.body = this._adapter.buildRequest(ctx.messages.getAll(), ctx.config, ctx.systemPrompts.getEnabled());
+		}
+		/** 车间 5：发送（流式/非流式 + 重试 + 占位消息 + _processResponse 工具钩子） */
+		async _stageSend(ctx) {
+			const retryCfg = this.config.retry || {};
+			ctx.result = await this._withRetry(ctx.body, {
+				isStream: ctx.isStream,
+				onProgress: ctx.onProgress,
+				onDone: ctx.onDone,
+				mergeToEntry: ctx.mergeToEntry,
+				config: ctx.config,
+				maxRetries: retryCfg.maxRetries ?? 0,
+				retryDelay: retryCfg.retryDelay ?? 1e3
+			});
+		}
 		_addUserMessage(userInput, addUser) {
 			if (addUser && userInput !== void 0) {
 				const msg = typeof userInput === "string" ? {
@@ -460,7 +753,7 @@
 			}
 		}
 		/** retry 循环，占位消息只 push 一次 */
-		async _withRetry(body, { isStream, onProgress, onDone, mergeToEntry, maxRetries, retryDelay }) {
+		async _withRetry(body, { isStream, onProgress, onDone, mergeToEntry, config, maxRetries, retryDelay }) {
 			let lastError = null;
 			const adapterOptions = { signal: this._abortController?.signal };
 			let placeholder = null;
@@ -496,10 +789,11 @@
 						base,
 						mergeToEntry,
 						onProgress,
-						onDone
+						onDone,
+						config
 					});
 					else {
-						const resp = await this._adapter.send(body, this.config, adapterOptions);
+						const resp = await this._adapter.send(body, config, adapterOptions);
 						let result = this._handleResult(this._adapter.parseResponse(resp), mergeToEntry);
 						if (this._processResponse && !mergeToEntry) result = await this._processResponse(result, { isStream: false });
 						return result;
@@ -518,12 +812,21 @@
 			this._isGenerating = false;
 			throw lastError;
 		}
-		/** 流式：ChatService 维护占位，adapter 只管解析 */
-		async _stream(body, adapterOptions, { placeholder, base, mergeToEntry, onProgress, onDone }) {
+		/**
+		* 流式处理：ChatService 维护占位消息，adapter 只负责解析 SSE
+		*
+		* 参数说明：
+		* - placeholder：流式期间实时更新的目标消息（续写时 = target 本身，普通发送时 = 新建的空消息）
+		* - base：续写时保存的旧内容快照，用于和 API 新内容拼接
+		* - mergeToEntry：续写目标的 id，有值时走续写逻辑
+		* - onProgress：外部回调，每收到一个 chunk 触发
+		* - onDone：流结束回调
+		*/
+		async _stream(body, adapterOptions, { placeholder, base, mergeToEntry, onProgress, onDone, config }) {
 			let finalMsg = null;
-			await this._adapter.stream(body, this.config, (snap) => {
-				placeholder.content = snap.content || "";
-				if (snap.reasoningContent) placeholder.reasoningContent = snap.reasoningContent;
+			await this._adapter.stream(body, config, (snap) => {
+				placeholder.content = mergeToEntry && base ? base.content + (snap.content || "") : snap.content || "";
+				if (snap.reasoningContent) placeholder.reasoningContent = mergeToEntry && base ? base.reasoning + snap.reasoningContent : snap.reasoningContent;
 				if (snap.toolCalls) placeholder.toolCalls = [...snap.toolCalls];
 				this.emit("stream-progress", snap);
 				if (onProgress) onProgress(snap);
@@ -537,7 +840,9 @@
 				if (mergeToEntry && base) {
 					const changes = {
 						content: base.content + (final.content || ""),
-						_complete: true
+						_complete: true,
+						_ephemeral: false,
+						prefix: void 0
 					};
 					if (final.reasoningContent) changes.reasoningContent = base.reasoning + final.reasoningContent;
 					if (final.toolCalls) changes.toolCalls = final.toolCalls;
@@ -564,7 +869,9 @@
 				}
 				const changes = {
 					content: (entry.content || "") + (assistantMsg.content || ""),
-					_complete: true
+					_complete: true,
+					_ephemeral: false,
+					prefix: void 0
 				};
 				if (assistantMsg.reasoningContent) changes.reasoningContent = (entry.reasoningContent || "") + assistantMsg.reasoningContent;
 				if (assistantMsg.toolCalls) changes.toolCalls = assistantMsg.toolCalls;
@@ -577,20 +884,44 @@
 			this.emit("message", assistantMsg);
 			return assistantMsg;
 		}
-		async send(userInput) {
+		/**
+		* 发送消息。
+		* @param {string|Object} userInput - 用户输入
+		* @param {Object} [params] - 请求级参数覆盖（model/temperature/modelParams 等，仅本次生效）
+		*/
+		async send(userInput, params) {
 			this._abortController = new AbortController();
 			try {
 				return await this._request({
 					userInput,
 					addUser: true,
-					isStream: false
+					isStream: false,
+					params
 				});
+			} catch (err) {
+				if (err.name === "AbortError") {
+					this.emit("aborted", { timestamp: Date.now() });
+					return;
+				}
+				throw err;
 			} finally {
 				this._abortController = null;
 				this._isGenerating = false;
 			}
 		}
-		async stream(userInput, onProgress, onDone) {
+		/**
+		* 流式发送。
+		* @param {string|Object} userInput - 用户输入
+		* @param {Object} [params] - 请求级参数覆盖（仅本次生效）
+		* @param {Function} [onProgress] - 流式进度回调
+		* @param {Function} [onDone] - 流式完成回调
+		*/
+		async stream(userInput, params, onProgress, onDone) {
+			if (typeof params === "function") {
+				onDone = onProgress;
+				onProgress = params;
+				params = void 0;
+			}
 			this._abortController = new AbortController();
 			try {
 				return await this._request({
@@ -598,40 +929,92 @@
 					addUser: true,
 					isStream: true,
 					onProgress,
-					onDone
+					onDone,
+					params
 				});
+			} catch (err) {
+				if (err.name === "AbortError") {
+					this.emit("aborted", { timestamp: Date.now() });
+					return;
+				}
+				throw err;
 			} finally {
 				this._abortController = null;
 				this._isGenerating = false;
 			}
 		}
-		async sendExisting() {
+		/**
+		* 重发当前消息（不加用户消息）。
+		* @param {Object} [params] - 请求级参数覆盖（仅本次生效）
+		*/
+		async sendExisting(params) {
 			this._abortController = new AbortController();
 			try {
 				return await this._request({
 					addUser: false,
-					isStream: false
+					isStream: false,
+					params
 				});
+			} catch (err) {
+				if (err.name === "AbortError") {
+					this.emit("aborted", { timestamp: Date.now() });
+					return;
+				}
+				throw err;
 			} finally {
 				this._abortController = null;
 				this._isGenerating = false;
 			}
 		}
-		async sendExistingStream(onProgress, onDone) {
+		/**
+		* 流式重发（不加用户消息）。
+		* @param {Object} [params] - 请求级参数覆盖（仅本次生效）
+		* @param {Function} [onProgress] - 流式进度回调
+		* @param {Function} [onDone] - 流式完成回调
+		*/
+		async sendExistingStream(params, onProgress, onDone) {
+			if (typeof params === "function") {
+				onDone = onProgress;
+				onProgress = params;
+				params = void 0;
+			}
 			this._abortController = new AbortController();
 			try {
 				return await this._request({
 					addUser: false,
 					isStream: true,
 					onProgress,
-					onDone
+					onDone,
+					params
 				});
+			} catch (err) {
+				if (err.name === "AbortError") {
+					this.emit("aborted", { timestamp: Date.now() });
+					return;
+				}
+				throw err;
 			} finally {
 				this._abortController = null;
 				this._isGenerating = false;
 			}
 		}
 	};
+	/**
+	* 校验 adapter 是否满足协议（v3.0 · 阶段 3）。
+	* 缺少必要方法时抛 ConfigurationError，并列出缺少的方法名——写"同级适配器"不再靠猜。
+	* @param {*} adapter
+	* @throws {ConfigurationError}
+	*/
+	function assertAdapter(adapter) {
+		if (!adapter || typeof adapter !== "object") throw new ConfigurationError("setAdapter: adapter 必须是对象（如 openaiAdapter / createOpenAIAdapter() 实例）");
+		const missing = [
+			"buildRequest",
+			"send",
+			"stream",
+			"parseResponse"
+		].filter((k) => typeof adapter[k] !== "function");
+		if (missing.length) throw new ConfigurationError(`setAdapter: adapter 缺少必要方法: ${missing.join(", ")}（协议见 ChatService.js 顶部的 @typedef ChatAdapter）`);
+	}
 	//#endregion
 	//#region src/utils/url.js
 	/**
@@ -809,17 +1192,48 @@
 	* OpenAI 兼容 API 适配器
 	* 支持 DeepSeek 等完全兼容 OpenAI 接口的服务
 	*/
+	var TRANSPORT_KEYS = [
+		"apiKey",
+		"baseUrl",
+		"apiUrl",
+		"path",
+		"headers"
+	];
 	var openaiAdapter = {
 		name: "openai",
-		install(chatService) {
+		install(chatService, options = {}) {
+			if (this._transport) this._transport = {
+				...this._transport,
+				...options
+			};
 			chatService.setAdapter(this);
 		},
+		_resolveConfig(config) {
+			const transport = this._transport || {};
+			const resolved = {
+				...config,
+				...transport
+			};
+			if (transport.modelParams) resolved.modelParams = {
+				...transport.modelParams,
+				...config.modelParams || {}
+			};
+			return resolved;
+		},
+		getRequestDefaults() {
+			if (!this._transport) return {};
+			const defaults = {};
+			for (const [key, value] of Object.entries(this._transport)) if (!TRANSPORT_KEYS.includes(key) && value !== void 0) defaults[key] = value;
+			return defaults;
+		},
 		buildRequest(messages, config, systemPrompts = []) {
+			config = this._resolveConfig(config);
 			const model = config.model || config.modelParams?.model;
 			if (!model) throw new Error("Missing required config: model (either at top level or in modelParams)");
-			const temperature = config.modelParams?.temperature ?? config.temperature ?? .7;
-			const maxTokens = config.modelParams?.maxTokens ?? config.maxTokens ?? 2e3;
-			const reasoningEffort = config.modelParams?.reasoningEffort ?? config.reasoningEffort;
+			const mp = config.modelParams || {};
+			const temperature = mp.temperature ?? config.temperature ?? .7;
+			const maxTokens = mp.maxTokens ?? config.maxTokens ?? 2e3;
+			const reasoningEffort = mp.reasoningEffort ?? config.reasoningEffort;
 			const requestBody = {
 				model,
 				messages: MessageFormatter.format({
@@ -833,11 +1247,30 @@
 				max_tokens: maxTokens,
 				stream: false
 			};
+			if (mp.topP !== void 0) requestBody.top_p = mp.topP;
+			if (mp.frequencyPenalty !== void 0) requestBody.frequency_penalty = mp.frequencyPenalty;
+			if (mp.presencePenalty !== void 0) requestBody.presence_penalty = mp.presencePenalty;
+			if (mp.stop !== void 0) requestBody.stop = mp.stop;
+			if (mp.responseFormat !== void 0) requestBody.response_format = mp.responseFormat;
+			if (mp.seed !== void 0) requestBody.seed = mp.seed;
 			if (config.tools && Array.isArray(config.tools) && config.tools.length > 0) {
 				requestBody.tools = config.tools;
 				requestBody.tool_choice = "auto";
 			}
-			if (reasoningEffort && model === "deepseek-reasoner") requestBody.reasoning_effort = reasoningEffort;
+			if (reasoningEffort !== void 0) requestBody.reasoning_effort = reasoningEffort;
+			const consumedKeys = new Set([
+				"model",
+				"temperature",
+				"maxTokens",
+				"reasoningEffort",
+				"topP",
+				"frequencyPenalty",
+				"presencePenalty",
+				"stop",
+				"responseFormat",
+				"seed"
+			]);
+			for (const [key, value] of Object.entries(mp)) if (!consumedKeys.has(key) && value !== void 0) requestBody[key] = value;
 			return requestBody;
 		},
 		_getUrl(config) {
@@ -850,6 +1283,7 @@
 		},
 		async send(requestBody, config, options = {}) {
 			try {
+				config = this._resolveConfig(config);
 				const url = this._getUrl(config);
 				const headers = {
 					"Content-Type": "application/json",
@@ -884,6 +1318,7 @@
 			return internal;
 		},
 		async stream(requestBody, config, onProgress, onDone, options = {}) {
+			config = this._resolveConfig(config);
 			const streamBody = {
 				...requestBody,
 				stream: true
@@ -977,165 +1412,213 @@
 			throw new APIError(errorMessage, response.status, null, errorText);
 		}
 	};
+	/**
+	* 创建 OpenAI 兼容适配器实例（工厂）。
+	*
+	* 与单例 openaiAdapter 的区别：每个实例自持一份运输配置（apiKey/baseUrl/apiUrl/path/headers），
+	* 互不干扰——解决"同一适配器装到多个 ChatService 互相覆盖"的单例陷阱。
+	*
+	* 用法：
+	*   const adapter = createOpenAIAdapter({ apiKey, baseUrl, modelParams: { temperature: 0.8 } });
+	*   const chat = new ChatService({ adapter, model: 'deepseek-chat' });
+	*   chat.use(adapter);  // 或直接 new ChatService({ adapter })
+	*
+	* 非运输键（model/modelParams/messageFormat/resolveImage/capabilities 等）会作为
+	* "请求默认参数"供会话层合并，单次请求仍可覆盖。
+	*/
+	function createOpenAIAdapter(options = {}) {
+		return {
+			...openaiAdapter,
+			_transport: { ...options }
+		};
+	}
 	//#endregion
 	//#region src/plugins/tool-calling.js
 	/**
 	* 工具调用插件
 	* 功能：拦截助手消息中的 tool_calls，执行对应的工具，将结果作为 tool 消息加入对话，
 	*       然后自动继续对话（通过 sendExisting / sendExistingStream），直到没有新的工具调用。
-	* 
+	*
 	* 设计要点：
 	* - 支持普通请求和流式请求（通过 isStream 标志区分）
 	* - 支持多次工具调用循环（maxIterations 防止无限循环）
-	* - 串行执行工具（可后续升级为并行）
+	* - 并行执行工具
 	* - 工具执行失败时，仍然返回错误信息给 AI，而不是中断整个流程
 	* - 触发 tool-error 事件，方便用户监听工具执行异常
+	*
+	* 注意：请使用 createToolCallingPlugin() 工厂创建实例。
+	* 默认导出的 toolCallingPlugin 是兼容用的模块级单例，装到多个 ChatService
+	* 实例会互相覆盖（executor 表、工具定义、配置），新代码不要直接用单例。
 	*/
-	var toolCallingPlugin = {
-		name: "tool-calling",
-		maxIterations: 5,
-		install(chatService) {
-			this.chatService = chatService;
-			this._tools = /* @__PURE__ */ new Map();
-			if (!chatService.config.tools) chatService.config.tools = [];
-			/**
-			* 注册工具
-			* @param {string} name - 工具名称（唯一标识）
-			* @param {string} description - 工具描述（告诉 AI 何时调用）
-			* @param {Function} executor - 异步执行函数，接收参数对象，返回结果（字符串或对象）
-			* @param {Object} parameters - JSON Schema 参数定义（可选，默认为空对象）
-			* @returns {ChatService} 返回 chatService 实例，支持链式调用
-			*/
-			chatService.registerTool = (name, description, executor, parameters = {}) => {
-				this._tools.set(name, {
-					executor,
-					description
+	var toolCallingPlugin = createToolCallingPlugin();
+	/**
+	* 创建工具调用插件实例（工厂）。
+	* @param {Object} [options] — { timeout, maxIterations }
+	*/
+	function createToolCallingPlugin(options = {}) {
+		return {
+			name: "tool-calling",
+			maxIterations: options.maxIterations || 5,
+			_options: { ...options },
+			_tools: /* @__PURE__ */ new Map(),
+			_toolDefs: [],
+			chatService: null,
+			install(chatService, options = {}) {
+				this._options = {
+					...this._options,
+					...options
+				};
+				this.chatService = chatService;
+				chatService.pipe({
+					name: "tool-calling-inject",
+					phase: "beforeSend",
+					run: ({ config }) => {
+						if (this._toolDefs.length) config.tools = this._toolDefs;
+					}
 				});
-				const toolDefinition = {
-					type: "function",
-					function: {
-						name,
-						description,
-						parameters: {
-							type: "object",
-							properties: parameters,
-							required: Object.keys(parameters).filter((key) => parameters[key]?.required)
+				/**
+				* 注册工具
+				* @param {string} name - 工具名称（唯一标识）
+				* @param {string} description - 工具描述（告诉 AI 何时调用）
+				* @param {Function} executor - 异步执行函数，接收参数对象，返回结果（字符串或对象）
+				* @param {Object} parameters - JSON Schema 参数定义（可选，默认为空对象）
+				* @returns {ChatService} 返回 chatService 实例，支持链式调用
+				*/
+				chatService.registerTool = (name, description, executor, parameters = {}) => {
+					this._tools.set(name, {
+						executor,
+						description
+					});
+					const toolDefinition = {
+						type: "function",
+						function: {
+							name,
+							description,
+							parameters: {
+								type: "object",
+								properties: parameters,
+								required: Object.keys(parameters).filter((key) => parameters[key]?.required)
+							}
 						}
-					}
+					};
+					if (!this._toolDefs.find((t) => t.function.name === name)) this._toolDefs.push(toolDefinition);
+					return chatService;
 				};
-				if (!chatService.config.tools.find((t) => t.function.name === name)) chatService.config.tools.push(toolDefinition);
-				return chatService;
-			};
-			chatService._processResponse = async (response, { isStream, onProgress, onDone }) => {
-				return this._handleWithTools(response, isStream, onProgress, onDone);
-			};
-		},
-		async _handleWithTools(initialResponse, isStream, onProgress, onDone) {
-			const self = this;
-			const chat = this.chatService;
-			let iteration = 0;
-			/**
-			* 递归处理工具调用
-			* @param {Object} initialResponse - 初始 AI 响应（可能是第一次请求的响应）
-			* @returns {Promise<Object>} 最终 AI 响应（不含 tool_calls）
-			*/
-			async function processResponse(initialResponse) {
-				let lastResponse = initialResponse;
-				while (iteration < self.maxIterations) {
-					const toolCalls = lastResponse?.toolCalls;
-					if (!toolCalls || toolCalls.length === 0) break;
-					iteration++;
-					const toolResults = await Promise.all(toolCalls.map(async (call) => {
-						const toolName = call.function?.name;
-						let args;
-						try {
-							args = JSON.parse(call.function?.arguments || "{}");
-						} catch (parseErr) {
-							chat.emit("tool-error", {
-								toolName: toolName || "unknown",
-								error: parseErr,
-								toolCallId: call.id,
-								stage: "parse",
-								timestamp: Date.now()
-							});
-							return {
-								tool_call_id: call.id,
-								error: `参数解析失败: ${parseErr.message}`,
-								success: false
-							};
-						}
-						const tool = self._tools.get(toolName);
-						if (!tool) {
-							chat.emit("tool-error", {
-								toolName,
-								error: /* @__PURE__ */ new Error(`Tool not registered: ${toolName}`),
-								toolCallId: call.id,
-								stage: "lookup",
-								timestamp: Date.now()
-							});
-							return {
-								tool_call_id: call.id,
-								error: `工具 ${toolName} 未注册`,
-								success: false
-							};
-						}
-						try {
-							const toolTimeout = chat.config.toolTimeout;
-							let execPromise = tool.executor(args);
-							if (toolTimeout && typeof toolTimeout === "number" && toolTimeout > 0) {
-								const timeoutErr = /* @__PURE__ */ new Error(`工具 ${toolName} 执行超时 (${toolTimeout}ms)`);
-								timeoutErr.name = "ToolTimeoutError";
-								const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(timeoutErr), toolTimeout));
-								execPromise = Promise.race([execPromise, timeoutPromise]);
+				chatService.pipe({
+					name: "tool-calling-loop",
+					phase: "afterSend",
+					run: async (ctx) => {
+						ctx.result = await this._handleWithTools(ctx.result, ctx.isStream, ctx.onProgress || void 0, ctx.onDone || void 0);
+					}
+				});
+			},
+			async _handleWithTools(initialResponse, isStream, onProgress, onDone) {
+				const self = this;
+				const chat = this.chatService;
+				let iteration = 0;
+				/**
+				* 递归处理工具调用
+				* @param {Object} initialResponse - 初始 AI 响应（可能是第一次请求的响应）
+				* @returns {Promise<Object>} 最终 AI 响应（不含 tool_calls）
+				*/
+				async function processResponse(initialResponse) {
+					let lastResponse = initialResponse;
+					while (iteration < self.maxIterations) {
+						const toolCalls = lastResponse?.toolCalls;
+						if (!toolCalls || toolCalls.length === 0) break;
+						iteration++;
+						const toolResults = await Promise.all(toolCalls.map(async (call) => {
+							const toolName = call.function?.name;
+							let args;
+							try {
+								args = JSON.parse(call.function?.arguments || "{}");
+							} catch (parseErr) {
+								chat.emit("tool-error", {
+									toolName: toolName || "unknown",
+									error: parseErr,
+									toolCallId: call.id,
+									stage: "parse",
+									timestamp: Date.now()
+								});
+								return {
+									tool_call_id: call.id,
+									error: `参数解析失败: ${parseErr.message}`,
+									success: false
+								};
 							}
-							const result = await execPromise;
-							chat.emit("tool-success", {
-								toolName,
-								result,
-								toolCallId: call.id,
-								timestamp: Date.now()
-							});
-							return {
-								tool_call_id: call.id,
-								content: typeof result === "string" ? result : JSON.stringify(result),
-								success: true
-							};
-						} catch (err) {
-							const stage = err.name === "ToolTimeoutError" ? "timeout" : "execute";
-							chat.emit("tool-error", {
-								toolName,
-								error: err,
-								toolCallId: call.id,
-								stage,
-								timestamp: Date.now()
-							});
-							return {
-								tool_call_id: call.id,
-								error: err.message,
-								success: false
-							};
+							const tool = self._tools.get(toolName);
+							if (!tool) {
+								chat.emit("tool-error", {
+									toolName,
+									error: /* @__PURE__ */ new Error(`Tool not registered: ${toolName}`),
+									toolCallId: call.id,
+									stage: "lookup",
+									timestamp: Date.now()
+								});
+								return {
+									tool_call_id: call.id,
+									error: `工具 ${toolName} 未注册`,
+									success: false
+								};
+							}
+							try {
+								const toolTimeout = self._options.timeout ?? chat.config.toolTimeout;
+								let execPromise = tool.executor(args);
+								if (toolTimeout && typeof toolTimeout === "number" && toolTimeout > 0) {
+									const timeoutErr = /* @__PURE__ */ new Error(`工具 ${toolName} 执行超时 (${toolTimeout}ms)`);
+									timeoutErr.name = "ToolTimeoutError";
+									const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(timeoutErr), toolTimeout));
+									execPromise = Promise.race([execPromise, timeoutPromise]);
+								}
+								const result = await execPromise;
+								chat.emit("tool-success", {
+									toolName,
+									result,
+									toolCallId: call.id,
+									timestamp: Date.now()
+								});
+								return {
+									tool_call_id: call.id,
+									content: typeof result === "string" ? result : JSON.stringify(result),
+									success: true
+								};
+							} catch (err) {
+								const stage = err.name === "ToolTimeoutError" ? "timeout" : "execute";
+								chat.emit("tool-error", {
+									toolName,
+									error: err,
+									toolCallId: call.id,
+									stage,
+									timestamp: Date.now()
+								});
+								return {
+									tool_call_id: call.id,
+									error: err.message,
+									success: false
+								};
+							}
+						}));
+						for (const tr of toolResults) {
+							const content = tr.success ? tr.content : tr.error || "工具执行失败";
+							chat.messages.addTool(content, tr.tool_call_id);
 						}
-					}));
-					for (const tr of toolResults) {
-						const content = tr.success ? tr.content : tr.error || "工具执行失败";
-						chat.messages.addTool(content, tr.tool_call_id);
-					}
-					if (isStream) await new Promise((resolve) => {
-						chat.sendExistingStream((chunk) => {
-							if (onProgress) onProgress(chunk);
-							lastResponse = chunk;
-						}, (final) => {
-							lastResponse = final;
-							resolve();
+						if (isStream) await new Promise((resolve) => {
+							chat.sendExistingStream((chunk) => {
+								if (onProgress) onProgress(chunk);
+								lastResponse = chunk;
+							}, (final) => {
+								lastResponse = final;
+								resolve();
+							});
 						});
-					});
-					else lastResponse = await chat.sendExisting();
+						else lastResponse = await chat.sendExisting();
+					}
+					return lastResponse;
 				}
-				return lastResponse;
+				return await processResponse(initialResponse);
 			}
-			return await processResponse(initialResponse);
-		}
-	};
+		};
+	}
 	//#endregion
 	//#region src/plugins/model-registry.js
 	/**
@@ -1242,56 +1725,83 @@
 		reasoning: false,
 		vision: false
 	};
-	var modelRegistryPlugin = {
-		name: "model-registry",
-		install(chatService) {
-			this.chat = chatService;
-			this._registry = new Map(Object.entries(BUILTIN_MODELS));
-			/**
-			* 注册/覆盖一个模型的能力标签
-			* @param {string} name — 模型名称
-			* @param {Object} capabilities — 能力标签对象（部分字段即可，未提供的取默认值）
-			* @returns {ChatService}
-			*/
-			chatService.registerModel = (name, capabilities = {}) => {
-				if (!name || typeof name !== "string" || !name.trim()) throw new Error("[model-registry] 模型名称必须是非空字符串");
-				const merged = {
-					...DEFAULT_CAPABILITIES,
-					...capabilities
+	/**
+	* 注意：请使用 createModelRegistryPlugin() 工厂创建实例。
+	* 默认导出的 modelRegistryPlugin 是兼容用的模块级单例，装到多个 ChatService
+	* 实例会互相覆盖（注册表、实例引用），新代码不要直接用单例。
+	*/
+	var modelRegistryPlugin = createModelRegistryPlugin();
+	/**
+	* 创建模型能力注册表插件实例（工厂）。
+	* @param {Object} [options] — { models: { '模型名': capabilities } }（合并进内置表）
+	*/
+	function createModelRegistryPlugin(options = {}) {
+		return {
+			name: "model-registry",
+			_options: { ...options },
+			_registry: new Map([...Object.entries(BUILTIN_MODELS), ...Object.entries(options.models || {})]),
+			chat: null,
+			install(chatService, options = {}) {
+				this._options = {
+					...this._options,
+					...options
 				};
-				this._registry.set(name.trim(), merged);
-				if (chatService.config.model === name.trim()) this._syncCapabilities();
-				return chatService;
-			};
-			/**
-			* 列出所有已注册的模型名称
-			* @returns {Array<string>}
-			*/
-			chatService.listModels = () => {
-				return [...this._registry.keys()];
-			};
-			this._syncCapabilities();
-			chatService.on("config-updated", ({ changes }) => {
-				if ("model" in changes) this._syncCapabilities();
-				if ("capabilities" in changes && !("model" in changes)) {
-					const current = this._lookupCapabilities();
-					if (current) chatService.config.capabilities = {
-						...current,
-						...changes.capabilities
+				this.chat = chatService;
+				/**
+				* 注册/覆盖一个模型的能力标签
+				* @param {string} name — 模型名称
+				* @param {Object} capabilities — 能力标签对象（部分字段即可，未提供的取默认值）
+				* @returns {ChatService}
+				*/
+				chatService.registerModel = (name, capabilities = {}) => {
+					if (!name || typeof name !== "string" || !name.trim()) throw new Error("[model-registry] 模型名称必须是非空字符串");
+					const merged = {
+						...DEFAULT_CAPABILITIES,
+						...capabilities
 					};
-				}
-			});
-		},
-		_lookupCapabilities() {
-			const model = this.chat.config.model;
-			if (!model) return null;
-			return this._registry.get(model) || null;
-		},
-		_syncCapabilities() {
-			const caps = this._lookupCapabilities();
-			if (caps) this.chat.config.capabilities = { ...caps };
-		}
-	};
+					this._registry.set(name.trim(), merged);
+					if (chatService.config.model === name.trim()) this._syncCapabilities();
+					return chatService;
+				};
+				/**
+				* 列出所有已注册的模型名称
+				* @returns {Array<string>}
+				*/
+				chatService.listModels = () => {
+					return [...this._registry.keys()];
+				};
+				this._syncCapabilities();
+				chatService.pipe({
+					name: "model-registry-caps",
+					phase: "beforeSend",
+					run: ({ config }) => {
+						if (!config.model) return;
+						const caps = this._registry.get(config.model);
+						if (caps) config.capabilities = { ...caps };
+					}
+				});
+				chatService.on("config-updated", ({ changes }) => {
+					if ("model" in changes) this._syncCapabilities();
+					if ("capabilities" in changes && !("model" in changes)) {
+						const current = this._lookupCapabilities();
+						if (current) chatService.config.capabilities = {
+							...current,
+							...changes.capabilities
+						};
+					}
+				});
+			},
+			_lookupCapabilities() {
+				const model = this.chat.config.model;
+				if (!model) return null;
+				return this._registry.get(model) || null;
+			},
+			_syncCapabilities() {
+				const caps = this._lookupCapabilities();
+				if (caps) this.chat.config.capabilities = { ...caps };
+			}
+		};
+	}
 	//#endregion
 	exports.APIError = APIError;
 	exports.ChatService = ChatService;
@@ -1301,8 +1811,13 @@
 	exports.MessageStore = MessageStore;
 	exports.NetworkError = NetworkError;
 	exports.ParsingError = ParsingError;
+	exports.Pipeline = Pipeline;
 	exports.SystemPromptStore = SystemPromptStore;
 	exports.assembleMessages = assembleMessages;
+	exports.assertAdapter = assertAdapter;
+	exports.createModelRegistryPlugin = createModelRegistryPlugin;
+	exports.createOpenAIAdapter = createOpenAIAdapter;
+	exports.createToolCallingPlugin = createToolCallingPlugin;
 	exports.modelRegistryPlugin = modelRegistryPlugin;
 	exports.openaiAdapter = openaiAdapter;
 	exports.toolCallingPlugin = toolCallingPlugin;