@vibe-lark/larkpal 0.1.33 → 0.1.37

package/dist/main.mjs

@@ -375,7 +375,8 @@ const TOOL_DISPLAY_NAMES = {
 	WebSearch: "正在搜索网页",
 	WebFetch: "正在获取网页内容",
 	TodoWrite: "正在更新任务列表",
-	Task: "正在执行子任务"
+	Task: "正在执行子任务",
+	_AutoCompact: "正在压缩对话历史"
 };
 /** 获取工具的中文显示名称，未知工具返回通用描述 */
 function getToolDisplayName(toolName) {
@@ -420,6 +421,13 @@ var CCStreamParser = class extends EventEmitter {
 			this.emit("parseError", err, trimmed);
 			return;
 		}
+		if (msg.parent_tool_use_id != null && msg.type !== "result") {
+			log$32.debug("跳过 subagent 内部事件", {
+				type: msg.type,
+				parentToolUseId: msg.parent_tool_use_id
+			});
+			return;
+		}
 		switch (msg.type) {
 			case "stream_event":
 				this.handleStreamEvent(msg);
@@ -524,6 +532,11 @@ var CCStreamParser = class extends EventEmitter {
 				this.emit("toolUseStart", block.name, block.input ?? {});
 			}
 		}
+		const usage = msg.message?.usage;
+		if (usage && typeof usage.input_tokens === "number") this.emit("usage", {
+			input_tokens: usage.input_tokens,
+			output_tokens: usage.output_tokens
+		});
 		this.emit("assistant", msg);
 	}
 	/**
@@ -876,6 +889,37 @@ const IDLE_TIMEOUT_MS = (() => {
 	if (isNaN(seconds) || seconds < 0) return 0;
 	return seconds * 1e3;
 })();
+/**
+* 自动压缩阈值（input_tokens 数）。
+*
+* 当 CC 返回的 input_tokens 超过此阈值时，在下一次用户消息发送前
+* 自动执行 /compact 命令压缩对话历史。
+*
+* 通过 LARKPAL_CC_AUTO_COMPACT_THRESHOLD 环境变量配置，默认 50000（50K tokens）。
+* 设为 0 表示禁用自动压缩。
+*
+* 参考数据：200K context 模型在 50K tokens 时 TTFT ≈ 7-10s（线性区间），
+* 超过后延迟快速增长。压缩后目标约 20-30K tokens。
+*/
+const AUTO_COMPACT_THRESHOLD = (() => {
+	const envVal = process.env.LARKPAL_CC_AUTO_COMPACT_THRESHOLD;
+	if (envVal === void 0 || envVal === "") return 5e4;
+	const tokens = parseInt(envVal, 10);
+	if (isNaN(tokens) || tokens < 0) return 5e4;
+	return tokens;
+})();
+/**
+* CC 推理努力级别。
+*
+* 控制模型的 thinking budget（思维深度），影响延迟和成本：
+*   low    — 最少思考，快速响应（简单问答）
+*   medium — 适度思考（推荐：平衡延迟与质量）
+*   high   — 较深思考（默认 CC 行为）
+*   xhigh/max — 最大思考（复杂推理）
+*
+* 通过 LARKPAL_CC_EFFORT 环境变量配置，默认 medium。
+*/
+const CC_EFFORT = process.env.LARKPAL_CC_EFFORT || "medium";
 /** 优雅关闭等待时间（5 秒） */
 const GRACEFUL_SHUTDOWN_MS = 5e3;
 var SessionProcessManager = class {
@@ -920,6 +964,13 @@ var SessionProcessManager = class {
 	messageCompletionResolvers = /* @__PURE__ */ new Map();
 	/** 消息级串行锁：确保同一 session 的消息按顺序处理完成 */
 	sessionLocks = /* @__PURE__ */ new Map();
+	/**
+	* 最近一次 CC 响应的 input_tokens：sessionId → token 数
+	*
+	* 由 parser 的 usage 事件更新。用于在下一次 executePrompt 前判断
+	* 是否需要自动触发 /compact 压缩对话历史。
+	*/
+	lastInputTokens = /* @__PURE__ */ new Map();
 	/** 标记 session 为用户主动中断 */
 	markAborted(sessionId) {
 		this.abortedSessions.add(sessionId);
@@ -983,6 +1034,7 @@ var SessionProcessManager = class {
 				pid: existing.childProcess.pid,
 				prepareMs: Date.now() - t0
 			});
+			await this.autoCompactIfNeeded(sessionId);
 			this.sendMessage(sessionId, config.prompt);
 			this.resetIdleTimer(sessionId);
 			await completionPromise;
@@ -1042,6 +1094,7 @@ var SessionProcessManager = class {
 		if (config.maxTurns) args.push("--max-turns", String(config.maxTurns));
 		if (config.maxBudgetUsd) args.push("--max-budget-usd", String(config.maxBudgetUsd));
 		if (config.model) args.push("--model", config.model);
+		args.push("--effort", CC_EFFORT);
 		if (config.userContext && !config.userContext.isTenantIdentity) try {
 			const mcpConfigPath = await mergeAndWriteMcpConfig(config.userContext, sessionId);
 			if (mcpConfigPath) {
@@ -1283,6 +1336,16 @@ var SessionProcessManager = class {
 			getCallbacks()?.onResult?.(result);
 			this.resolveMessageCompletion(sessionId);
 		});
+		parser.on("usage", (usage) => {
+			this.lastInputTokens.set(sessionId, usage.input_tokens);
+			log$29.info("[auto-compact] 更新 input_tokens", {
+				sessionId,
+				inputTokens: usage.input_tokens,
+				outputTokens: usage.output_tokens,
+				threshold: AUTO_COMPACT_THRESHOLD,
+				needsCompact: AUTO_COMPACT_THRESHOLD > 0 && usage.input_tokens > AUTO_COMPACT_THRESHOLD
+			});
+		});
 		parser.on("parseError", (error, rawLine) => {
 			log$29.warn("流解析错误", {
 				sessionId,
@@ -1382,6 +1445,111 @@ var SessionProcessManager = class {
 		});
 	}
 	/**
+	* 检查是否需要自动压缩，如需要则执行 /compact 命令
+	*
+	* 判断逻辑：
+	*   1. AUTO_COMPACT_THRESHOLD > 0（未禁用）
+	*   2. lastInputTokens[sessionId] > threshold
+	*
+	* 执行方式：通过 stdin 发送 "/compact" 作为用户消息，等待 CC 返回 result。
+	* compact 期间：
+	*   - 通过 callbacks.onToolUseStart 通知 UI 显示"正在压缩对话历史"
+	*   - compact 产生的文本/result 被静默回调吞掉，不泄露到用户卡片
+	*   - compact 完成后通过 callbacks.onToolResult 通知 UI 压缩完成
+	*/
+	async autoCompactIfNeeded(sessionId) {
+		if (AUTO_COMPACT_THRESHOLD <= 0) return;
+		const lastTokens = this.lastInputTokens.get(sessionId);
+		if (!lastTokens || lastTokens <= AUTO_COMPACT_THRESHOLD) return;
+		log$29.info("[auto-compact] 触发自动压缩", {
+			sessionId,
+			lastInputTokens: lastTokens,
+			threshold: AUTO_COMPACT_THRESHOLD
+		});
+		const tCompact = Date.now();
+		const realCallbacks = this.activeCallbacks.get(sessionId);
+		const compactToolUseId = `compact-${Date.now()}`;
+		realCallbacks?.onToolUseStart?.("_AutoCompact", {
+			inputTokens: lastTokens,
+			threshold: AUTO_COMPACT_THRESHOLD
+		});
+		this.activeCallbacks.set(sessionId, {
+			onTextDelta: () => {},
+			onThinkingDelta: () => {},
+			onToolUseStart: () => {},
+			onToolResult: () => {},
+			onToolProgress: () => {},
+			onTurnEnd: () => {},
+			onResult: () => {},
+			onError: (err) => {
+				log$29.warn("[auto-compact] compact 期间收到错误", {
+					sessionId,
+					error: err.message
+				});
+			}
+		});
+		try {
+			await this.sendCompactCommand(sessionId);
+			this.lastInputTokens.delete(sessionId);
+			log$29.info("[auto-compact] 压缩完成", {
+				sessionId,
+				durationMs: Date.now() - tCompact
+			});
+		} catch (err) {
+			log$29.warn("[auto-compact] 压缩失败，继续发送原始消息", {
+				sessionId,
+				error: err instanceof Error ? err.message : String(err),
+				durationMs: Date.now() - tCompact
+			});
+		} finally {
+			if (realCallbacks) this.activeCallbacks.set(sessionId, realCallbacks);
+			realCallbacks?.onToolResult?.(compactToolUseId);
+		}
+	}
+	/**
+	* 向 CC 进程发送 /compact 命令并等待完成
+	*
+	* /compact 是 CC 的内置 slash command，通过 stdin 作为用户消息发送。
+	* CC 会压缩对话历史并返回 result 事件表示完成。
+	*
+	* 超时 120 秒（compact 可能需要处理大量历史）。
+	*/
+	sendCompactCommand(sessionId) {
+		const proc = this.processes.get(sessionId);
+		if (!proc || proc.status !== "running") return Promise.reject(/* @__PURE__ */ new Error(`会话 ${sessionId} 无运行中的进程，无法执行 compact`));
+		if (!proc.childProcess.stdin || proc.childProcess.stdin.destroyed) return Promise.reject(/* @__PURE__ */ new Error(`会话 ${sessionId} 的 stdin 不可用，无法执行 compact`));
+		const COMPACT_TIMEOUT_MS = 12e4;
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`/compact 超时 (${COMPACT_TIMEOUT_MS}ms)`));
+			}, COMPACT_TIMEOUT_MS);
+			const completionPromise = this.createMessageCompletionPromise(sessionId);
+			const compactPayload = JSON.stringify({
+				type: "user",
+				message: {
+					role: "user",
+					content: "/compact"
+				},
+				parent_tool_use_id: null,
+				uuid: v4()
+			});
+			log$29.info("[auto-compact] 发送 /compact 命令", {
+				sessionId,
+				pid: proc.childProcess.pid
+			});
+			proc.childProcess.stdin.write(compactPayload + "\n", (err) => {
+				if (err) {
+					clearTimeout(timer);
+					reject(/* @__PURE__ */ new Error(`/compact stdin 写入失败: ${err.message}`));
+				}
+			});
+			completionPromise.then(() => {
+				clearTimeout(timer);
+				resolve();
+			});
+		});
+	}
+	/**
 	* 获取指定会话的最近一条用户消息 ID
 	*
 	* 用于构建回退按钮的 action value。
@@ -1397,6 +1565,10 @@ var SessionProcessManager = class {
 	getSessionCwd(sessionId) {
 		return this.sessionCwdCache.get(sessionId);
 	}
+	/** 检查指定 session 是否正在执行消息（CC 尚未返回 result） */
+	isSessionBusy(sessionId) {
+		return this.messageCompletionResolvers.has(sessionId);
+	}
 	/**
 	* 为 rewind 操作临时启动一个 CC 进程
 	*
@@ -1526,6 +1698,7 @@ var SessionProcessManager = class {
 		this.processes.delete(sessionId);
 		this.activeCallbacks.delete(sessionId);
 		this.lastUserMessageIds.delete(sessionId);
+		this.lastInputTokens.delete(sessionId);
 		for (const [reqId, pending] of this.pendingControlRequests) if (pending.sessionId === sessionId) {
 			clearTimeout(pending.timer);
 			this.pendingControlRequests.delete(reqId);
@@ -1645,6 +1818,9 @@ var ClaudeCodeAdapter = class ClaudeCodeAdapter {
 			lastActiveAt: proc.lastActiveAt
 		}));
 	}
+	isSessionBusy(sessionId) {
+		return this.processManager.isSessionBusy(sessionId);
+	}
 };
 //#endregion
 //#region src/runtime/larkpal-agent-factory.ts
@@ -1700,16 +1876,16 @@ async function createLarkpalAgentAdapter() {
 		maxTurns: defaultMaxTurns
 	});
 	const { LarkpalAgentAdapter, ToolRegistry } = await import("@vibe-lark/larkpal-agent");
+	const registry = new ToolRegistry();
 	const adapter = new LarkpalAgentAdapter({
 		llm,
 		systemPrompt,
 		tools: [],
-		defaultMaxTurns
+		defaultMaxTurns,
+		registry
 	});
 	const mcpServerUrl = process.env.LARKPAL_AGENT_MCP_SERVER_URL;
-	let registry = null;
 	if (mcpServerUrl) try {
-		registry = new ToolRegistry();
 		const toolCount = await registry.connectMcpServer(mcpServerUrl, { timeoutMs: 1e4 });
 		const tools = registry.getAll();
 		adapter.registerTools(tools);
@@ -1730,7 +1906,7 @@ async function createLarkpalAgentAdapter() {
 		const { fileURLToPath } = await import("node:url");
 		const skillsDir = join(fileURLToPath(import.meta.resolve("@vibe-lark/larkpal-agent")).replace(/\/dist\/index\.js$/, ""), "src", "skills", "definitions");
 		const skills = await loadSkillsFromDir(skillsDir);
-		if (skills.length > 0 && registry) {
+		if (skills.length > 0) {
 			registerSkills(registry, skills, llm);
 			const skillTools = registry.getAll().filter((t) => t.name.startsWith("skill:"));
 			adapter.registerTools(skillTools);
@@ -1738,8 +1914,7 @@ async function createLarkpalAgentAdapter() {
 				skillCount: skills.length,
 				skillNames: skills.map((s) => s.name)
 			});
-		} else if (skills.length > 0 && !registry) log$27.warn("Skills 已加载但无 ToolRegistry（MCP 未连接），跳过 Meta-Tool 注册");
-		else log$27.info("未找到 Skill 定义文件", { skillsDir });
+		} else log$27.info("未找到 Skill 定义文件", { skillsDir });
 	} catch (err) {
 		log$27.warn("Skill 加载失败（非阻塞）", { error: err?.message });
 	}
@@ -1983,6 +2158,15 @@ async function handleExecute(req, res, processManager) {
 		sessionId: body.session_id,
 		mode
 	});
+	if (!body.auth_headers) {
+		const tenantKey = req.headers["x-tenant-key"];
+		const userId = req.headers["x-user-id"];
+		if (tenantKey || userId) {
+			body.auth_headers = {};
+			if (tenantKey) body.auth_headers["x-tenant-key"] = tenantKey;
+			if (userId) body.auth_headers["x-user-id"] = userId;
+		}
+	}
 	const config = {
 		sessionId: body.session_id,
 		cwd: body.cwd,
@@ -1993,7 +2177,8 @@ async function handleExecute(req, res, processManager) {
 			baseURL: body.llm_config.base_url,
 			apiKey: body.llm_config.api_key,
 			model: body.llm_config.model
-		} } : {}
+		} } : {},
+		...body.auth_headers ? { authHeaders: body.auth_headers } : {}
 	};
 	if (mode === "async") {
 		const callbacks = createTaskCallbacks(taskId);
@@ -5810,7 +5995,7 @@ var CCStreamBridge = class {
 		});
 		if (this.options.autoCompleteOnTurnEnd && stopReason === "end_turn") {
 			const trimmedText = this.accumulatedText.trim();
-			if (trimmedText === CC_INTERNAL_PLACEHOLDER || trimmedText === "") {
+			if (trimmedText === CC_INTERNAL_PLACEHOLDER) {
 				log$19.info("检测到 CC 内部占位消息，静默丢弃", {
 					text: trimmedText.slice(0, 50),
 					sessionKey: this.options.sessionKey
@@ -5818,6 +6003,10 @@ var CCStreamBridge = class {
 				this.controller.abortCard();
 				return;
 			}
+			if (trimmedText === "") {
+				log$19.info("turnEnd 时文本为空，延迟到 onResult 兜底处理", { sessionKey: this.options.sessionKey });
+				return;
+			}
 			this.controller.markFullyComplete();
 			this.controller.onIdle();
 		}
@@ -5851,7 +6040,19 @@ var CCStreamBridge = class {
 				});
 				this.controller.onError(new Error(errorMessage), { kind: "cc-execution" });
 			}
+		} else if (!this.accumulatedText.trim()) if (data.result) {
+			log$19.info("result 兜底：使用 result.result 作为最终回复", {
+				resultLen: data.result.length,
+				sessionKey: this.options.sessionKey
+			});
+			this.controller.onPartialReply({ text: data.result });
+			this.controller.markFullyComplete();
+			this.controller.onIdle();
 		} else {
+			log$19.info("result 兜底：无文本且无 result，abort 卡片", { sessionKey: this.options.sessionKey });
+			this.controller.abortCard();
+		}
+		else {
 			this.controller.markFullyComplete();
 			this.controller.onIdle();
 		}
@@ -9722,7 +9923,7 @@ function formatContentByType(ctx) {
 			}
 			return content;
 		case "merge_forward": return content;
-		case "audio": return "[语音消息 - 暂不支持转文字]";
+		case "audio": return content || "[语音消息]";
 		case "sticker": return content || "[表情贴纸]";
 		case "video":
 		case "media": return content || "[视频消息]";
@@ -9847,7 +10048,7 @@ async function dispatchToCC(params) {
 	const replyInThread = !!threadId;
 	const replyToMessageId = threadId ? void 0 : ctx.messageId;
 	let textPrompt = formatForCC(ctx, isGroup);
-	if (isGroup) textPrompt = `[直接@你的消息，请正常回复] ${textPrompt}`;
+	if (isGroup) textPrompt = `[有人@你] ${textPrompt}`;
 	const imageResources = ctx.resources.filter((r) => r.type === "image");
 	let prompt = textPrompt;
 	if (imageResources.length > 0) {
@@ -9933,6 +10134,28 @@ async function dispatchToCC(params) {
 				textLength: textPrompt.length,
 				imageCount: imageBlocks.length
 			});
+		} else {
+			const textWithoutImageRefs = textPrompt.replace(/!\[image\]\([^)]*\)/g, "").replace(/\[图片\]\s*/g, "").trim();
+			if (textWithoutImageRefs.length > 0) {
+				prompt = textPrompt.replace(/!\[image\]\([^)]*\)/g, "[图片加载失败]");
+				log$12.info("图片下载失败但保留文字内容继续调度", {
+					messageId: ctx.messageId,
+					textLength: textWithoutImageRefs.length
+				});
+			} else {
+				log$12.warn("纯图片消息且图片全部下载失败，中止调度", {
+					messageId: ctx.messageId,
+					expectedImages: imageResources.length
+				});
+				await LarkClient.fromAccount(account).sdk.im.message.reply({
+					path: { message_id: ctx.messageId },
+					data: {
+						content: JSON.stringify({ text: "图片下载失败，请稍后重新发送。" }),
+						msg_type: "text"
+					}
+				});
+				return;
+			}
 		}
 	}
 	const attachmentResources = ctx.resources.filter((r) => r.type === "file" || r.type === "audio" || r.type === "video" || r.type === "sticker");
@@ -10040,11 +10263,19 @@ async function dispatchToCC(params) {
 				}
 			}
 		} catch (err) {
-			log$12.warn("非图片附件下载失败，保留原始占位符", {
+			log$12.warn("非图片附件下载失败，替换为降级描述", {
 				type: res.type,
 				fileKey: res.fileKey,
 				error: err instanceof Error ? err.message : String(err)
 			});
+			const fallbackRegex = new RegExp(`<${res.type}\\s+key="${res.fileKey}"[^/]*/>`, "g");
+			const fallbackMap = {
+				file: `[文件: ${res.fileName || "未知"} - 下载失败]`,
+				audio: "[语音消息 - 下载失败]",
+				video: `[视频: ${res.fileName || "未知"} - 下载失败]`,
+				sticker: "[表情贴纸 - 加载失败]"
+			};
+			updatedTextPrompt = updatedTextPrompt.replace(fallbackRegex, fallbackMap[res.type] || `[${res.type} - 下载失败]`);
 		}
 		if (typeof prompt === "string") prompt = updatedTextPrompt;
 		else {
@@ -10254,6 +10485,13 @@ async function dispatchTeammateEval(params) {
 		userId: void 0,
 		userName: void 0
 	});
+	if (processManager.isSessionBusy?.(route.sessionId)) {
+		log$12.info("dispatchTeammateEval 跳过：主 session 正在执行", {
+			chatId,
+			sessionId: route.sessionId
+		});
+		return { replied: false };
+	}
 	await sessionRouter.ensureSessionDirectory(route);
 	const teammateSessionKey = `teammate_${route.sessionId}`;
 	startToolUseTraceRun(teammateSessionKey);
@@ -10322,11 +10560,12 @@ async function dispatchTeammateEval(params) {
 		pendingToolEvents.length = 0;
 	};
 	/**
-	* 处理 text delta — 全量缓冲，直到 end_turn 时统一判断
+	* 处理 text delta — 前缀检测 + 缓冲
 	* 
-	* 策略：CC 在 teammate 模式下可能先执行工具再输出文本，且文本中可能正文在前、
-	* NO_REPLY 在末尾。因此不做前缀检测，而是缓冲所有 text，在 onTurnEnd(end_turn)
-	* 时统一判断完整输出是否包含 NO_REPLY。
+	* 策略：prompt 要求 CC 如果决定不参与，必须首先输出 NO_REPLY。
+	* 因此在缓冲阶段做前缀检测：如果 fullTextBuffer 以 NO_REPLY 开头则立即静默。
+	* 这比等 end_turn 快得多（可提前 10-30s 结束评估等待）。
+	* 兜底：end_turn 时再做最终判断（应对 CC 不遵守 prompt 约束的情况）。
 	*/
 	const handleTextDelta = (text) => {
 		if (silenced) return;
@@ -10335,6 +10574,13 @@ async function dispatchTeammateEval(params) {
 			return;
 		}
 		fullTextBuffer += text;
+		if (fullTextBuffer.trimStart().startsWith(NO_REPLY_TOKEN)) {
+			silenced = true;
+			log$12.info("teammate 前缀检测: 检测到 NO_REPLY 首输出，立即静默", {
+				chatId,
+				bufferLen: fullTextBuffer.length
+			});
+		}
 	};
 	try {
 		await new Promise((resolve) => {
@@ -12370,13 +12616,13 @@ async function parseMessageEvent(event, botOpenId, expandCtx) {
 	const mentionsByOpenId = /* @__PURE__ */ new Map();
 	for (const info of mentionList) mentionsByOpenId.set(info.openId, info);
 	const acctId = expandCtx?.accountId;
-	const larkClient = expandCtx ? LarkClient.fromCfg(expandCtx.cfg, acctId) : void 0;
+	const larkClient = expandCtx ? expandCtx.larkClient ?? (expandCtx.cfg ? LarkClient.fromCfg(expandCtx.cfg, acctId) : void 0) : void 0;
 	let fetchSubMessages;
 	let batchResolveNames;
-	if (expandCtx) {
-		const account = getLarkAccount(expandCtx.cfg, acctId);
+	if (expandCtx && larkClient) {
+		const account = expandCtx.account ?? (expandCtx.cfg ? getLarkAccount(expandCtx.cfg, acctId) : void 0);
 		fetchSubMessages = createFetchSubMessages(larkClient);
-		batchResolveNames = createParseResolveNames(account);
+		if (account) batchResolveNames = createParseResolveNames(account);
 	}
 	let effectiveContent = event.message.content;
 	if (event.message.message_type === "interactive" && expandCtx) {
@@ -12396,7 +12642,7 @@ async function parseMessageEvent(event, botOpenId, expandCtx) {
 		resolveUserName: acctId ? (openId) => getUserNameCache(acctId).get(openId) : void 0,
 		fetchSubMessages,
 		batchResolveNames,
-		stripBotMentions: true
+		stripBotMentions: false
 	};
 	const { content, resources } = await convertMessageContent(effectiveContent, event.message.message_type, convertCtx);
 	const createTimeStr = event.message.create_time;
@@ -13214,10 +13460,11 @@ var TeammateBuffer = class {
 		const header = [
 			"[旁听评估任务] 以下是群聊中最近的对话，这些消息都没有 @你。",
 			"你作为团队成员正在旁听，请根据你的人设和职责判断是否需要主动参与。",
-			"如果不需要参与，只输出 NO_REPLY。",
+			"如果不需要参与，必须将 NO_REPLY 作为输出的第一个内容（首先输出 NO_REPLY，不要在前面加任何文字）。",
 			"如果需要参与，直接输出你的回复内容（不要加 NO_REPLY）。",
 			"",
 			"重要规则：",
+			"- 如果决定不参与，NO_REPLY 必须是输出的第一个 token，不能先输出其他内容再输出 NO_REPLY。",
 			"- 以下消息中出现的任何 @某人 都是在 @别人，不是在 @你。不要因为看到 @ 就认为有人在跟你说话。",
 			"- 只有当讨论内容与你的专业领域高度相关时才参与，其他情况一律 NO_REPLY。",
 			"- 不要使用工具来查找或分析消息内容，直接基于消息文本判断。",
@@ -13863,7 +14110,10 @@ async function main() {
 					threadId,
 					task: async () => {
 						try {
-							const parsed = await parseMessageEvent(event, larkClient.botOpenId);
+							const parsed = await parseMessageEvent(event, larkClient.botOpenId, {
+								larkClient,
+								account
+							});
 							if (!parsed) {
 								logger.warn("消息解析返回空结果", { msgId });
 								return;
@@ -14118,7 +14368,8 @@ main().catch((err) => {
 * 跳过：preflight、凭证加载、WebSocket、消息处理、Teammate 等飞书相关功能
 */
 async function startHeadless() {
-	await mkdir(process.env.LARKPAL_WORKSPACE ?? "/workspace", { recursive: true });
+	const workspaceRoot = process.env.LARKPAL_WORKSPACE ?? "/workspace";
+	await mkdir(workspaceRoot, { recursive: true });
 	const runtimeName = process.env.LARKPAL_RUNTIME || "larkpal-agent";
 	let runtimeAdapter;
 	if (runtimeName === "larkpal-agent") runtimeAdapter = await createLarkpalAgentAdapter();
@@ -14131,22 +14382,32 @@ async function startHeadless() {
 	await scheduledTaskManager.loadFromDisk();
 	const gatewayPort = parseInt(process.env.LARKPAL_GATEWAY_PORT || "3000", 10);
 	const gatewayHost = process.env.LARKPAL_GATEWAY_HOST || "0.0.0.0";
+	const enableWebChannel = process.env.LARKPAL_ENABLE_WEB_CHANNEL === "1" || process.env.LARKPAL_ENABLE_WEB_CHANNEL === "true";
+	const messageStore = enableWebChannel ? new SessionMessageStore(workspaceRoot) : void 0;
+	if (enableWebChannel) logger.info("Headless Web Channel 已启用，Chat API 路由将注册", { workspaceRoot });
 	const gateway = createGatewayServer({
 		port: gatewayPort,
 		host: gatewayHost,
 		processManager: runtimeAdapter,
 		scheduledTaskManager,
 		appCredentials: void 0,
-		messageStore: void 0
+		messageStore
 	});
 	await gateway.start();
 	logger.info("🚀 LarkPal Headless Gateway 启动完成", {
 		gatewayUrl: `http://${gatewayHost}:${gatewayPort}`,
 		runtime: runtimeName,
+		webChannel: enableWebChannel,
 		endpoints: [
 			"/api/execute",
 			"/api/status",
-			"/api/skills"
+			"/api/skills",
+			...enableWebChannel ? [
+				"/api/chat/auth",
+				"/api/chat/stream",
+				"/api/chat/sessions",
+				"/api/chat/history"
+			] : []
 		]
 	});
 	const shutdown = async (signal) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-lark/larkpal",
-  "version": "0.1.33",
+  "version": "0.1.37",
   "description": "LarkPal - Lark/Feishu bot service",
   "type": "module",
   "main": "./dist/main.mjs",
@@ -19,21 +19,9 @@
     "registry": "https://registry.npmjs.org",
     "access": "public"
   },
-  "packageManager": "pnpm@10.32.1",
   "engines": {
     "node": ">=22"
   },
-  "scripts": {
-    "start": "node --env-file=.env bin/larkpal.js",
-    "build": "tsdown",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "lint": "eslint src/",
-    "lint:fix": "eslint src/ --fix",
-    "typecheck": "tsc --noEmit",
-    "format": "prettier --write src/**/*.ts",
-    "format:check": "prettier --check src/**/*.ts"
-  },
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.60.0",
     "@sinclair/typebox": "0.34.48",
@@ -63,5 +51,16 @@
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.32.1",
     "vitest": "^4.1.1"
+  },
+  "scripts": {
+    "start": "node --env-file=.env bin/larkpal.js",
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write src/**/*.ts",
+    "format:check": "prettier --check src/**/*.ts"
   }
-}
+}