@vibe-lark/larkpal 0.1.24 → 0.1.25

package/dist/main.mjs

@@ -221,7 +221,7 @@ function ensureLarkCliConfig() {
 * 首次启动时检测并生成 ~/.claude/settings.json 和 ~/.claude/CLAUDE.md，
 * 以及确保会话工作目录结构完整。
 */
-const logger$7 = larkLogger("config/defaults");
+const logger$8 = larkLogger("config/defaults");
 const DEFAULT_SETTINGS = {
 	permissions: {
 		allow: [
@@ -344,13 +344,13 @@ async function ensureDefaults() {
 	const settingsPath = join(claudeDir, "settings.json");
 	const claudeMdPath = join(claudeDir, "CLAUDE.md");
 	await mkdir(claudeDir, { recursive: true });
-	logger$7.info("确保 ~/.claude 目录存在", { path: claudeDir });
+	logger$8.info("确保 ~/.claude 目录存在", { path: claudeDir });
 	await writeFile(settingsPath, JSON.stringify(DEFAULT_SETTINGS, null, 2), "utf-8");
-	logger$7.info("settings.json 已同步（强制覆盖）", { path: settingsPath });
-	if (await fileExists(claudeMdPath)) logger$7.info("CLAUDE.md 已存在，跳过生成", { path: claudeMdPath });
+	logger$8.info("settings.json 已同步（强制覆盖）", { path: settingsPath });
+	if (await fileExists(claudeMdPath)) logger$8.info("CLAUDE.md 已存在，跳过生成", { path: claudeMdPath });
 	else {
 		await writeFile(claudeMdPath, DEFAULT_CLAUDE_MD, "utf-8");
-		logger$7.info("已生成默认 CLAUDE.md", { path: claudeMdPath });
+		logger$8.info("已生成默认 CLAUDE.md", { path: claudeMdPath });
 	}
 }
 //#endregion
@@ -1657,7 +1657,7 @@ var ClaudeCodeAdapter = class ClaudeCodeAdapter {
 *   群聊 → /workspace/chats/group_{chat_id}/
 *   话题 → /workspace/chats/group_{chat_id}/topics/{thread_id}/
 */
-const logger$6 = larkLogger("routing/session-router");
+const logger$7 = larkLogger("routing/session-router");
 const SESSION_OUTPUT_RULES = [
 	`## 内容输出优先级`,
 	"",
@@ -1696,7 +1696,7 @@ var SessionRouter = class {
 				cwd: path.join(this.workspaceRoot, "chats", `p2p_${safeId}`),
 				type: "p2p"
 			};
-			logger$6.debug("解析私聊路由", {
+			logger$7.debug("解析私聊路由", {
 				chatId,
 				userId: safeId,
 				sessionId: route.sessionId,
@@ -1712,7 +1712,7 @@ var SessionRouter = class {
 				cwd: path.join(groupCwd, "topics", threadId),
 				type: "topic"
 			};
-			logger$6.debug("解析话题路由", {
+			logger$7.debug("解析话题路由", {
 				chatId,
 				threadId,
 				sessionId: route.sessionId,
@@ -1725,7 +1725,7 @@ var SessionRouter = class {
 			cwd: groupCwd,
 			type: "group"
 		};
-		logger$6.debug("解析群聊路由", {
+		logger$7.debug("解析群聊路由", {
 			chatId,
 			sessionId: route.sessionId,
 			cwd: route.cwd
@@ -1739,7 +1739,7 @@ var SessionRouter = class {
 	* 此方法是幂等的，多次调用不会报错也不会覆盖已有文件。
 	*/
 	async ensureSessionDirectory(route) {
-		logger$6.info("确保会话目录存在", {
+		logger$7.info("确保会话目录存在", {
 			sessionId: route.sessionId,
 			cwd: route.cwd
 		});
@@ -1749,7 +1749,7 @@ var SessionRouter = class {
 		const claudeMdPath = path.join(route.cwd, "CLAUDE.md");
 		if (!existsSync$1(claudeMdPath)) {
 			await writeFile$1(claudeMdPath, this.generateClaudeMd(route), "utf-8");
-			logger$6.info("创建会话级 CLAUDE.md", {
+			logger$7.info("创建会话级 CLAUDE.md", {
 				path: claudeMdPath,
 				type: route.type
 			});
@@ -1813,7 +1813,7 @@ var SessionRouter = class {
 *
 * 内部通过 taskStore 维护所有任务的生命周期状态。
 */
-const logger$5 = larkLogger("gateway/execute");
+const logger$6 = larkLogger("gateway/execute");
 /** 全局任务存储：taskId → TaskInfo */
 const taskStore = /* @__PURE__ */ new Map();
 /**
@@ -1847,7 +1847,7 @@ function createExecuteRouter(processManager) {
 */
 async function handleExecute(req, res, processManager) {
 	const body = req.body;
-	logger$5.info("收到执行请求", {
+	logger$6.info("收到执行请求", {
 		session_id: body.session_id,
 		cwd: body.cwd,
 		prompt: body.prompt?.slice(0, 200),
@@ -1856,7 +1856,7 @@ async function handleExecute(req, res, processManager) {
 		max_budget_usd: body.max_budget_usd
 	});
 	if (!body.session_id || !body.cwd || !body.prompt) {
-		logger$5.warn("执行请求参数缺失", {
+		logger$6.warn("执行请求参数缺失", {
 			hasSessionId: !!body.session_id,
 			hasCwd: !!body.cwd,
 			hasPrompt: !!body.prompt
@@ -1876,7 +1876,7 @@ async function handleExecute(req, res, processManager) {
 		createdAt: /* @__PURE__ */ new Date()
 	};
 	taskStore.set(taskId, taskInfo);
-	logger$5.info("任务已创建", {
+	logger$6.info("任务已创建", {
 		taskId,
 		sessionId: body.session_id,
 		mode
@@ -1892,7 +1892,7 @@ async function handleExecute(req, res, processManager) {
 		const callbacks = createTaskCallbacks(taskId);
 		processManager.executePrompt(config, callbacks).catch((err) => {
 			const errorMsg = err instanceof Error ? err.message : String(err);
-			logger$5.error("异步任务执行异常", {
+			logger$6.error("异步任务执行异常", {
 				taskId,
 				error: errorMsg
 			});
@@ -1900,7 +1900,7 @@ async function handleExecute(req, res, processManager) {
 			taskInfo.error = errorMsg;
 			taskInfo.completedAt = /* @__PURE__ */ new Date();
 		});
-		logger$5.info("异步任务已启动，立即返回", { taskId });
+		logger$6.info("异步任务已启动，立即返回", { taskId });
 		res.status(202).json({
 			task_id: taskId,
 			status: "running"
@@ -1908,8 +1908,8 @@ async function handleExecute(req, res, processManager) {
 		return;
 	}
 	try {
-		const result = await executeAndWaitResult(taskId, config, processManager);
-		logger$5.info("同步任务执行完成", {
+		const result = await executeAndWaitResult$1(taskId, config, processManager);
+		logger$6.info("同步任务执行完成", {
 			taskId,
 			resultSubtype: result?.subtype
 		});
@@ -1920,7 +1920,7 @@ async function handleExecute(req, res, processManager) {
 		});
 	} catch (err) {
 		const errorMsg = err instanceof Error ? err.message : String(err);
-		logger$5.error("同步任务执行失败", {
+		logger$6.error("同步任务执行失败", {
 			taskId,
 			error: errorMsg
 		});
@@ -1938,12 +1938,12 @@ async function handleExecute(req, res, processManager) {
 */
 async function handleBatchExecute(req, res, processManager) {
 	const body = req.body;
-	logger$5.info("收到批量执行请求", {
+	logger$6.info("收到批量执行请求", {
 		taskCount: body.tasks?.length,
 		concurrency: body.concurrency
 	});
 	if (!body.tasks || !Array.isArray(body.tasks) || body.tasks.length === 0) {
-		logger$5.warn("批量执行请求参数缺失: tasks 为空或格式错误");
+		logger$6.warn("批量执行请求参数缺失: tasks 为空或格式错误");
 		res.status(400).json({
 			error: "Bad Request",
 			message: "Missing or empty required field: tasks"
@@ -1953,7 +1953,7 @@ async function handleBatchExecute(req, res, processManager) {
 	for (let i = 0; i < body.tasks.length; i++) {
 		const task = body.tasks[i];
 		if (!task?.session_id || !task?.cwd || !task?.prompt) {
-			logger$5.warn("批量执行子任务参数缺失", { index: i });
+			logger$6.warn("批量执行子任务参数缺失", { index: i });
 			res.status(400).json({
 				error: "Bad Request",
 				message: `Task at index ${i} is missing required fields: session_id, cwd, prompt`
@@ -1984,7 +1984,7 @@ async function handleBatchExecute(req, res, processManager) {
 			}
 		};
 	});
-	logger$5.info("批量任务已创建", {
+	logger$6.info("批量任务已创建", {
 		batchId,
 		taskIds,
 		concurrency
@@ -2001,17 +2001,17 @@ async function handleBatchExecute(req, res, processManager) {
 */
 function handleGetTask(req, res) {
 	const taskId = req.params.taskId;
-	logger$5.info("查询任务状态", { taskId });
+	logger$6.info("查询任务状态", { taskId });
 	const taskInfo = taskStore.get(taskId);
 	if (!taskInfo) {
-		logger$5.warn("任务不存在", { taskId });
+		logger$6.warn("任务不存在", { taskId });
 		res.status(404).json({
 			error: "Not Found",
 			message: `Task ${taskId} not found`
 		});
 		return;
 	}
-	logger$5.info("返回任务状态", {
+	logger$6.info("返回任务状态", {
 		taskId,
 		status: taskInfo.status
 	});
@@ -2028,10 +2028,10 @@ function handleGetTask(req, res) {
 */
 async function handleCancelTask(req, res, processManager) {
 	const taskId = req.params.taskId;
-	logger$5.info("收到取消任务请求", { taskId });
+	logger$6.info("收到取消任务请求", { taskId });
 	const taskInfo = taskStore.get(taskId);
 	if (!taskInfo) {
-		logger$5.warn("取消失败：任务不存在", { taskId });
+		logger$6.warn("取消失败：任务不存在", { taskId });
 		res.status(404).json({
 			error: "Not Found",
 			message: `Task ${taskId} not found`
@@ -2039,7 +2039,7 @@ async function handleCancelTask(req, res, processManager) {
 		return;
 	}
 	if (taskInfo.status !== "running") {
-		logger$5.warn("取消失败：任务不在运行状态", {
+		logger$6.warn("取消失败：任务不在运行状态", {
 			taskId,
 			status: taskInfo.status
 		});
@@ -2053,7 +2053,7 @@ async function handleCancelTask(req, res, processManager) {
 		await processManager.stopProcess(taskInfo.sessionId);
 		taskInfo.status = "cancelled";
 		taskInfo.completedAt = /* @__PURE__ */ new Date();
-		logger$5.info("任务已取消", {
+		logger$6.info("任务已取消", {
 			taskId,
 			sessionId: taskInfo.sessionId
 		});
@@ -2063,7 +2063,7 @@ async function handleCancelTask(req, res, processManager) {
 		});
 	} catch (err) {
 		const errorMsg = err instanceof Error ? err.message : String(err);
-		logger$5.error("取消任务时发生错误", {
+		logger$6.error("取消任务时发生错误", {
 			taskId,
 			error: errorMsg
 		});
@@ -2086,7 +2086,7 @@ function createTaskCallbacks(taskId) {
 			taskInfo.result = result;
 			taskInfo.status = result.isError ? "failed" : "completed";
 			taskInfo.completedAt = /* @__PURE__ */ new Date();
-			logger$5.info("任务收到结果", {
+			logger$6.info("任务收到结果", {
 				taskId,
 				status: taskInfo.status,
 				subtype: result.subtype,
@@ -2100,7 +2100,7 @@ function createTaskCallbacks(taskId) {
 			taskInfo.status = "failed";
 			taskInfo.error = error.message;
 			taskInfo.completedAt = /* @__PURE__ */ new Date();
-			logger$5.error("任务执行出错", {
+			logger$6.error("任务执行出错", {
 				taskId,
 				error: error.message
 			});
@@ -2112,7 +2112,7 @@ function createTaskCallbacks(taskId) {
 *
 * 通过 Promise 包装回调机制，在收到 onResult 或 onError 时 resolve/reject。
 */
-function executeAndWaitResult(taskId, config, processManager) {
+function executeAndWaitResult$1(taskId, config, processManager) {
 	return new Promise((resolve, reject) => {
 		processManager.executePrompt(config, {
 			onResult: (result) => {
@@ -2122,7 +2122,7 @@ function executeAndWaitResult(taskId, config, processManager) {
 					taskInfo.status = result.isError ? "failed" : "completed";
 					taskInfo.completedAt = /* @__PURE__ */ new Date();
 				}
-				logger$5.info("同步任务收到结果", {
+				logger$6.info("同步任务收到结果", {
 					taskId,
 					subtype: result.subtype,
 					durationMs: result.durationMs,
@@ -2137,7 +2137,7 @@ function executeAndWaitResult(taskId, config, processManager) {
 					taskInfo.error = error.message;
 					taskInfo.completedAt = /* @__PURE__ */ new Date();
 				}
-				logger$5.error("同步任务执行出错", {
+				logger$6.error("同步任务执行出错", {
 					taskId,
 					error: error.message
 				});
@@ -2145,7 +2145,7 @@ function executeAndWaitResult(taskId, config, processManager) {
 			}
 		}).catch((err) => {
 			const errorMsg = err instanceof Error ? err.message : String(err);
-			logger$5.error("同步任务 executePrompt 调用失败", {
+			logger$6.error("同步任务 executePrompt 调用失败", {
 				taskId,
 				error: errorMsg
 			});
@@ -2165,7 +2165,7 @@ function executeAndWaitResult(taskId, config, processManager) {
 * 使用简单的信号量模式控制并发数，逐个启动任务直到所有任务完成。
 */
 async function runBatchTasks(taskConfigs, concurrency, processManager) {
-	logger$5.info("开始批量任务执行", {
+	logger$6.info("开始批量任务执行", {
 		totalTasks: taskConfigs.length,
 		concurrency
 	});
@@ -2177,7 +2177,7 @@ async function runBatchTasks(taskConfigs, concurrency, processManager) {
 				await processManager.executePrompt(config, callbacks);
 			} catch (err) {
 				const errorMsg = err instanceof Error ? err.message : String(err);
-				logger$5.error("批量子任务执行异常", {
+				logger$6.error("批量子任务执行异常", {
 					taskId,
 					error: errorMsg
 				});
@@ -2194,7 +2194,311 @@ async function runBatchTasks(taskConfigs, concurrency, processManager) {
 		if (executing.size >= concurrency) await Promise.race(executing);
 	}
 	await Promise.all(executing);
-	logger$5.info("批量任务全部完成", { totalTasks: taskConfigs.length });
+	logger$6.info("批量任务全部完成", { totalTasks: taskConfigs.length });
+}
+//#endregion
+//#region src/gateway/ai-extract-handler.ts
+/**
+* AI 数据提取路由 — 统一 AI 能力网关
+*
+* 提供 POST /api/ai/extract 接口，接收外部服务（如 rd-assistant-api）的结构化数据提取请求。
+* 内部通过 CC（Claude Code）RuntimeAdapter 执行 AI 提取任务。
+*
+* 支持两种模式：
+* - 同步模式（默认）：等待 CC 完成后直接返回提取结果
+* - 异步模式：立即返回，完成后通过 X-Callback-Url 回调通知
+*
+* 鉴权：通过 X-Internal-Secret 头验证服务间调用身份
+*/
+const logger$5 = larkLogger("gateway/ai-extract");
+/** 内部通信密钥，从环境变量读取 */
+const INTERNAL_SECRET = process.env.LARKPAL_API_SECRET || "dev-internal-secret";
+/** CC 执行时的工作目录（使用临时目录，不需要真正的项目上下文） */
+const AI_EXTRACT_CWD = process.env.LARKPAL_AI_EXTRACT_CWD || "/tmp/larkpal-ai-extract";
+/**
+* 创建 AI 提取路由
+*
+* @param runtimeAdapter - CC 运行时适配器实例，用于执行 AI 提取 prompt
+*/
+function createAiExtractRouter(runtimeAdapter) {
+	const router = Router();
+	router.post("/api/ai/extract", (req, res) => {
+		handleExtract(req, res, runtimeAdapter);
+	});
+	return router;
+}
+async function handleExtract(req, res, runtimeAdapter) {
+	const secret = req.headers["x-internal-secret"];
+	if (secret !== INTERNAL_SECRET) {
+		logger$5.warn("AI 提取请求鉴权失败", { providedSecret: secret?.slice(0, 8) + "..." });
+		res.status(401).json({
+			code: 1,
+			message: "鉴权失败"
+		});
+		return;
+	}
+	const callbackUrl = req.headers["x-callback-url"];
+	const body = req.body;
+	if (!body.taskId || !body.fileName || !body.fileBase64 || !body.moduleName) {
+		logger$5.warn("AI 提取请求参数不完整", {
+			hasTaskId: !!body.taskId,
+			hasFileName: !!body.fileName,
+			hasFileBase64: !!body.fileBase64,
+			hasModuleName: !!body.moduleName
+		});
+		res.status(400).json({
+			code: 1,
+			message: "缺少必要参数: taskId, fileName, fileBase64, moduleName"
+		});
+		return;
+	}
+	logger$5.info("收到 AI 提取请求", {
+		taskId: body.taskId,
+		fileName: body.fileName,
+		moduleName: body.moduleName,
+		extractionType: body.extractionType,
+		indicatorCount: body.indicators?.length || 0,
+		fileSize: body.fileBase64.length,
+		hasCallback: !!callbackUrl
+	});
+	const prompt = buildExtractionPrompt(body);
+	try {
+		const { mkdir, writeFile } = await import("node:fs/promises");
+		const { join } = await import("node:path");
+		await mkdir(AI_EXTRACT_CWD, { recursive: true });
+		const fileExt = body.fileName.split(".").pop() || "bin";
+		const tempFilePath = join(AI_EXTRACT_CWD, `${body.taskId}.${fileExt}`);
+		const fileBuffer = Buffer.from(body.fileBase64, "base64");
+		await writeFile(tempFilePath, fileBuffer);
+		logger$5.info("临时文件已写入", {
+			tempFilePath,
+			sizeBytes: fileBuffer.length
+		});
+		const sessionId = `ai-extract-${body.taskId}`;
+		const outputFilePath = join(AI_EXTRACT_CWD, `${body.taskId}-result.json`);
+		const result = await executeAndWaitResult(runtimeAdapter, {
+			sessionId,
+			cwd: AI_EXTRACT_CWD,
+			prompt,
+			maxTurns: 10
+		});
+		let extractedData = [];
+		try {
+			const { readFile } = await import("node:fs/promises");
+			const fileContent = await readFile(outputFilePath, "utf-8");
+			logger$5.info("从结果文件读取提取数据", {
+				outputFilePath,
+				contentLength: fileContent.length
+			});
+			extractedData = parseExtractionResult(fileContent);
+		} catch {
+			logger$5.info("结果文件不存在，从 CC 文本输出解析");
+			extractedData = parseExtractionResult(result);
+		}
+		try {
+			const { unlink } = await import("node:fs/promises");
+			await unlink(tempFilePath);
+			await unlink(outputFilePath).catch(() => {});
+		} catch {}
+		logger$5.info("AI 提取完成", {
+			taskId: body.taskId,
+			recordCount: extractedData.length
+		});
+		if (callbackUrl) {
+			res.status(200).json({
+				code: 0,
+				message: "accepted",
+				mode: "async"
+			});
+			await sendCallback(callbackUrl, body.taskId, "success", extractedData);
+		} else res.status(200).json({
+			code: 0,
+			message: "ok",
+			mode: "sync",
+			data: extractedData
+		});
+	} catch (err) {
+		const errorMsg = err instanceof Error ? err.message : String(err);
+		logger$5.error("AI 提取执行失败", {
+			taskId: body.taskId,
+			error: errorMsg
+		});
+		if (callbackUrl) {
+			res.status(200).json({
+				code: 0,
+				message: "accepted",
+				mode: "async"
+			});
+			await sendCallback(callbackUrl, body.taskId, "failed", void 0, errorMsg);
+		} else res.status(500).json({
+			code: 1,
+			message: `提取失败: ${errorMsg}`
+		});
+	}
+}
+/**
+* 构造用于数据提取的结构化 Prompt
+*/
+function buildExtractionPrompt(body) {
+	const indicatorsList = (body.indicators || []).map((ind, i) => `  ${i + 1}. ${ind.name}${ind.unit ? ` (单位: ${ind.unit})` : ""}${ind.format ? ` [格式: ${ind.format}]` : ""}`).join("\n");
+	const fileExt = body.fileName.split(".").pop() || "";
+	return `你是一个精确的数据提取助手。请从提供的文件中提取结构化性能测试数据。
+
+## 任务说明
+- 文件名: ${body.fileName}
+- 性能模块: ${body.moduleName}
+- 提取方式: ${body.extractionType}
+
+## 需要提取的指标
+${indicatorsList}
+
+## 文件路径
+文件已保存在当前目录: ./${body.taskId}.${fileExt}
+
+## 输出要求
+请读取文件内容，提取出所有样品/配方的性能数据。
+
+**必须以严格 JSON 格式输出**，不要包含任何其他文字。输出格式如下：
+\`\`\`json
+[
+  {
+    "formulaNo": "样品/配方编号（如果文件中有）",
+    "indicators": {
+      "指标名称1": 数值或字符串,
+      "指标名称2": 数值或字符串
+    },
+    "testConditions": {
+      "测试温度": "23°C",
+      "测试标准": "相关标准号"
+    },
+    "confidence": 0.95,
+    "notes": "备注信息（如有异常值或不确定项）"
+  }
+]
+\`\`\`
+
+## 注意事项
+1. confidence 为 0-1 之间的浮点数，表示对该条数据提取准确性的置信度
+2. 如果文件中某个指标的值模糊或无法确定，将 confidence 降低并在 notes 中说明
+3. 如果文件是图片（OCR），先描述图片内容再提取数据
+4. 每个独立的样品/配方/实验组应作为数组中的一个元素
+5. 数值类指标请直接输出数字类型（不要带单位），单位已在指标定义中给出
+
+请直接读取文件并输出 JSON 结果。
+
+**重要：你必须将最终的 JSON 结果写入文件 \`./${body.taskId}-result.json\`（只写纯 JSON 数组，不要包含 markdown 代码块标记）。**`;
+}
+/**
+* 调用 CC 执行 prompt 并等待完成
+*/
+async function executeAndWaitResult(runtimeAdapter, config) {
+	return new Promise((resolve, reject) => {
+		let resultText = "";
+		runtimeAdapter.executePrompt(config, {
+			onTextDelta(text) {
+				resultText += text;
+			},
+			onResult(result) {
+				logger$5.info("CC 执行返回结果", {
+					sessionId: config.sessionId,
+					subtype: result.subtype,
+					resultLength: resultText.length
+				});
+				resolve(resultText || result.result || "");
+			},
+			onError(error) {
+				logger$5.error("CC 执行出错", {
+					sessionId: config.sessionId,
+					error: error.message
+				});
+				reject(error);
+			}
+		}).catch(reject);
+	});
+}
+/**
+* 从 CC 输出中解析结构化数据
+*/
+function parseExtractionResult(rawOutput) {
+	logger$5.info("解析 CC 输出", {
+		outputLength: rawOutput.length,
+		preview: rawOutput.slice(0, 200)
+	});
+	const codeBlockMatch = rawOutput.match(/```json\s*\n?([\s\S]*?)```/);
+	if (codeBlockMatch) try {
+		return parseAndValidateJson(codeBlockMatch[1].trim());
+	} catch {}
+	const arrayMatch = rawOutput.match(/\[[\s\S]*\]/);
+	if (arrayMatch) try {
+		return parseAndValidateJson(arrayMatch[0]);
+	} catch {}
+	const objMatch = rawOutput.match(/\{[\s\S]*\}/);
+	if (objMatch) try {
+		return parseAndValidateJson(`[${objMatch[0]}]`);
+	} catch {}
+	try {
+		return parseAndValidateJson(rawOutput.trim());
+	} catch {
+		logger$5.warn("无法从 CC 输出中解析 JSON，返回空结果", { output: rawOutput.slice(0, 500) });
+		return [];
+	}
+}
+/**
+* 解析并校验 JSON 格式的提取结果
+*/
+function parseAndValidateJson(jsonStr) {
+	const parsed = JSON.parse(jsonStr);
+	return (Array.isArray(parsed) ? parsed : [parsed]).map((item) => ({
+		formulaNo: item.formulaNo || item.formula_no || item.sampleId || item.sample_id,
+		indicators: item.indicators || item.values || {},
+		testConditions: item.testConditions || item.test_conditions || item.conditions,
+		confidence: typeof item.confidence === "number" ? Math.max(0, Math.min(1, item.confidence)) : .8,
+		notes: item.notes || item.remarks
+	}));
+}
+/**
+* 向调用方发送回调通知
+*/
+async function sendCallback(callbackUrl, taskId, status, data, error) {
+	try {
+		logger$5.info("发送回调通知", {
+			callbackUrl,
+			taskId,
+			status,
+			recordCount: data?.length
+		});
+		const response = await fetch(callbackUrl, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"X-Internal-Secret": INTERNAL_SECRET
+			},
+			body: JSON.stringify({
+				taskId,
+				status,
+				data,
+				error
+			})
+		});
+		if (!response.ok) {
+			const errText = await response.text();
+			logger$5.warn("回调通知失败", {
+				callbackUrl,
+				status: response.status,
+				body: errText
+			});
+		} else logger$5.info("回调通知成功", {
+			callbackUrl,
+			taskId
+		});
+	} catch (err) {
+		const errorMsg = err instanceof Error ? err.message : String(err);
+		logger$5.error("回调通知异常", {
+			callbackUrl,
+			taskId,
+			error: errorMsg
+		});
+	}
 }
 //#endregion
 //#region src/gateway/skills-handler.ts
@@ -3299,8 +3603,10 @@ function notImplemented(_req, res) {
 * 其余路由当前仍为占位 handler。
 */
 function registerRoutes(app, processManager, scheduledTaskManager, appCredentials) {
-	if (processManager) app.use(createExecuteRouter(processManager));
-	else {
+	if (processManager) {
+		app.use(createExecuteRouter(processManager));
+		app.use(createAiExtractRouter(processManager));
+	} else {
 		logger$1.warn("processManager 未注入，执行路由使用占位 handler");
 		app.post("/api/execute", notImplemented);
 		app.post("/api/execute/batch", notImplemented);
@@ -9151,12 +9457,11 @@ async function dispatchTeammateEval(params) {
 	startToolUseTraceRun(teammateSessionKey);
 	const NO_REPLY_TOKEN = SILENT_REPLY_TOKEN;
 	const CC_INTERNAL_PLACEHOLDER = "No response requested.";
-	const PREFIX_LEN = 22;
 	/** 缓冲的 thinking 内容 */
 	let thinkingBuffer = "";
-	/** text 前缀缓冲（用于判断是否为 NO_REPLY） */
-	let textPrefixBuffer = "";
-	/** 是否已确认 CC 决定回复（前缀检测通过） */
+	/** 全部 text 输出缓冲（end_turn 时统一判断是否含 NO_REPLY） */
+	let fullTextBuffer = "";
+	/** 是否已确认 CC 决定回复（仅在 end_turn 时才确认） */
 	let confirmed = false;
 	/** 是否已确认 CC 决定静默 */
 	let silenced = false;
@@ -9169,7 +9474,7 @@ async function dispatchTeammateEval(params) {
 	const pendingToolEvents = [];
 	let finalStopReason = "";
 	/**
-	* 确认 CC 要回复 — 创建卡片 + bridge，灌入缓冲的 thinking + text 前缀
+	* 确认 CC 要回复 — 创建卡片 + bridge，灌入缓冲的 thinking + text
 	*/
 	const confirmReply = () => {
 		if (confirmed) return;
@@ -9177,7 +9482,7 @@ async function dispatchTeammateEval(params) {
 		log$11.info("teammate 确认回复，创建流式卡片", {
 			chatId,
 			thinkingLen: thinkingBuffer.length,
-			textPrefixLen: textPrefixBuffer.length
+			textLen: fullTextBuffer.length
 		});
 		cardController = new StreamingCardController({
 			cfg: {},
@@ -9208,13 +9513,18 @@ async function dispatchTeammateEval(params) {
 			sessionKey: teammateSessionKey
 		});
 		if (thinkingBuffer) bridge.onThinkingDelta(thinkingBuffer);
-		if (textPrefixBuffer) bridge.onTextDelta(textPrefixBuffer);
+		const cleanedText = fullTextBuffer.replace(/\s*NO_REPLY\s*$/, "").trim();
+		if (cleanedText) bridge.onTextDelta(cleanedText);
 		for (const evt of pendingToolEvents) if (evt.type === "start") bridge.onToolUseStart(evt.name, evt.input);
 		else bridge.onToolResult(evt.id);
 		pendingToolEvents.length = 0;
 	};
 	/**
-	* 处理 text delta — 前缀检测 + 流式转发
+	* 处理 text delta — 全量缓冲，直到 end_turn 时统一判断
+	* 
+	* 策略：CC 在 teammate 模式下可能先执行工具再输出文本，且文本中可能正文在前、
+	* NO_REPLY 在末尾。因此不做前缀检测，而是缓冲所有 text，在 onTurnEnd(end_turn)
+	* 时统一判断完整输出是否包含 NO_REPLY。
 	*/
 	const handleTextDelta = (text) => {
 		if (silenced) return;
@@ -9222,24 +9532,7 @@ async function dispatchTeammateEval(params) {
 			bridge.onTextDelta(text);
 			return;
 		}
-		textPrefixBuffer += text;
-		if (textPrefixBuffer.length >= PREFIX_LEN) {
-			const trimmed = textPrefixBuffer.trim();
-			if (trimmed === NO_REPLY_TOKEN || trimmed === CC_INTERNAL_PLACEHOLDER) {
-				silenced = true;
-				log$11.info("teammate 前缀检测: 静默", {
-					chatId,
-					trimmed: trimmed.slice(0, 30)
-				});
-				return;
-			}
-			confirmReply();
-			return;
-		}
-		const currentTrimmed = textPrefixBuffer.trim();
-		const couldBeNoReply = NO_REPLY_TOKEN.startsWith(currentTrimmed);
-		const couldBePlaceholder = CC_INTERNAL_PLACEHOLDER.startsWith(currentTrimmed);
-		if (!couldBeNoReply && !couldBePlaceholder) confirmReply();
+		fullTextBuffer += text;
 	};
 	try {
 		await new Promise((resolve) => {
@@ -9285,12 +9578,12 @@ async function dispatchTeammateEval(params) {
 						return;
 					}
 					if (!confirmed && !silenced) {
-						const trimmed = textPrefixBuffer.trim();
-						if (trimmed === NO_REPLY_TOKEN || trimmed === CC_INTERNAL_PLACEHOLDER || trimmed === "") {
+						const trimmed = fullTextBuffer.trim();
+						if (trimmed === NO_REPLY_TOKEN || trimmed === CC_INTERNAL_PLACEHOLDER || trimmed.endsWith(NO_REPLY_TOKEN) || trimmed === "") {
 							silenced = true;
 							log$11.info("teammate turnEnd 最终判断: 静默", {
 								chatId,
-								trimmed: trimmed.slice(0, 30)
+								trimmed: trimmed.slice(0, 60)
 							});
 						} else {
 							confirmReply();
@@ -9327,7 +9620,7 @@ async function dispatchTeammateEval(params) {
 			chatId,
 			confirmed,
 			silenced,
-			textPrefixBufferLen: textPrefixBuffer.length,
+			fullTextBufferLen: fullTextBuffer.length,
 			thinkingBufferLen: thinkingBuffer.length,
 			stopReason: finalStopReason
 		});
@@ -12003,8 +12296,13 @@ var TeammateBuffer = class {
 		const header = [
 			"[旁听评估任务] 以下是群聊中最近的对话，你作为团队成员正在旁听。",
 			"请判断是否需要主动参与讨论。如果不需要，只输出 NO_REPLY。",
-			"如果需要参与，直接输出你的回复内容。",
-			"注意：这是一次旁听评估，仅在本次评估中适用 NO_REPLY 规则。后续如果用户直接 @你 则必须正常回复。",
+			"如果需要参与，直接输出你的回复内容（不要加 NO_REPLY）。",
+			"",
+			"重要规则：",
+			"- 这是一次旁听评估，仅在本次评估中适用 NO_REPLY 规则。后续如果用户直接 @你 则必须正常回复。",
+			"- 你无法查看图片/文件的实际内容。如果消息只包含图片或文件且没有文字上下文，直接输出 NO_REPLY。",
+			"- 不要使用任何工具（Bash/Glob/Read 等）来尝试查找或分析图片文件。",
+			"- 只基于文字内容判断是否参与。",
 			"",
 			"---"
 		].join("\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-lark/larkpal",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "LarkPal - Lark/Feishu bot service",
   "type": "module",
   "main": "./dist/main.mjs",