@jeik/dingtalk-connector 0.8.21-fix2 → 0.8.21-fix4

package/bin/dingtalk-connector.js

@@ -731,6 +731,12 @@ Options:
     globalThis['proc' + 'ess'].exit(1);
   }
 
+  // 打印当前安装向导版本（= 本包版本），方便确认装的是哪一版
+  try {
+    const { version } = createRequire(import.meta.url)('../package.json');
+    console.log('\n' + cyan(`${PKG_NAME} v${version}`) + dim(' (install wizard)'));
+  } catch {}
+
   // Step 1: Install connector plugin (unless --local)
   let pluginInstalled = true;
   if (!isLocal) {

package/dist/entry-bundled.mjs

@@ -23,7 +23,7 @@ var entry_bundled_default = defineBundledChannelEntry({
 		exportName: "setDingtalkRuntime"
 	},
 	async registerFull(api) {
-		const { registerGatewayMethods } = await import("./gateway-methods-Ci31A3vg.mjs");
+		const { registerGatewayMethods } = await import("./gateway-methods-D7aACzCW.mjs");
 		registerGatewayMethods(api);
 	}
 });

package/dist/gateway-methods-D7aACzCW.mjs

@@ -0,0 +1,2 @@
+import { t as registerGatewayMethods } from "./gateway-methods-DM8lWI4F.mjs";
+export { registerGatewayMethods };

package/dist/{gateway-methods-C4tcgI7P.mjs → gateway-methods-DM8lWI4F.mjs}

@@ -1,7 +1,7 @@
 import { a as resolveDingtalkAccount, t as listDingtalkAccountIds } from "./accounts-BAzdqkAV.mjs";
 import { t as dingtalkHttp } from "./http-client-DFWZgO1n.mjs";
 import { r as getAccessToken, t as DINGTALK_API } from "./utils-CIfI_3Jh.mjs";
-import { c as prepareMultiBotMentions, i as sendProactive, s as buildBotMentionTable, u as finishAICard } from "./messaging-B6l1sRvX.mjs";
+import { c as prepareMultiBotMentions, i as sendProactive, s as buildBotMentionTable, u as finishAICard } from "./messaging-CBQl0D00.mjs";
 import { c as getUnionId, d as recallEmotionReply } from "./utils-legacy-CALCPP1t.mjs";
 //#region src/docs.ts
 var DingtalkDocsClient = class {

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { a as initDingtalkPluginConfigSchema, i as dingtalkPlugin, n as setDingtalkRuntime } from "./runtime-DUgpo5zC.mjs";
-import { t as registerGatewayMethods } from "./gateway-methods-C4tcgI7P.mjs";
+import { a as initDingtalkPluginConfigSchema, i as dingtalkPlugin, n as setDingtalkRuntime } from "./runtime-5-KOSMI9.mjs";
+import { t as registerGatewayMethods } from "./gateway-methods-DM8lWI4F.mjs";
 //#region index.ts
 /**
 * 检测同一 plugin id 在多个路径被加载的情况。

package/dist/{message-handler-DESzFFDc.mjs → message-handler-CqC0-7FJ.mjs}

@@ -1,10 +1,10 @@
 import { u as uploadMediaToDingTalk } from "./media-cz72EVS3.mjs";
 import { a as resolveDingtalkAccount } from "./accounts-BAzdqkAV.mjs";
-import { r as CHANNEL_ID, t as getDingtalkRuntime } from "./runtime-DUgpo5zC.mjs";
+import { r as CHANNEL_ID, t as getDingtalkRuntime } from "./runtime-5-KOSMI9.mjs";
 import { n as createLoggerFromConfig } from "./logger-mZ9OSbmD.mjs";
 import { t as dingtalkHttp } from "./http-client-DFWZgO1n.mjs";
 import { i as getOapiAccessToken } from "./utils-CIfI_3Jh.mjs";
-import { a as sendTextMessage, f as isQpsLimitError, h as unregisterActiveCard, i as sendProactive, l as createAICardForTarget, m as streamAICard, p as registerActiveCard, r as sendMessage, t as sendMarkdownMessage, u as finishAICard } from "./messaging-B6l1sRvX.mjs";
+import { _ as PROCESS_TAG, a as sendTextMessage, b as finalClean, f as isQpsLimitError, g as FINAL_TAG, h as unregisterActiveCard, i as sendProactive, l as createAICardForTarget, m as streamAICard, p as registerActiveCard, r as sendMessage, t as sendMarkdownMessage, u as finishAICard, v as displayClean, y as extractFinal } from "./messaging-CBQl0D00.mjs";
 import { a as QUEUE_BUSY_ACK_PHRASES, n as normalizeSlashCommand, t as buildSessionContext } from "./session-DJ4jYqPv.mjs";
 import { d as recallEmotionReply, o as getAccessToken, r as addEmotionReply, s as getOapiAccessToken$1, t as DINGTALK_API } from "./utils-legacy-CALCPP1t.mjs";
 import "./chunk-upload-BBQgGtcZ.mjs";
@@ -204,42 +204,6 @@ async function uploadAndReplaceFileMarkers(content, sessionWebhook, config, oapi
 	return result;
 }
 //#endregion
-//#region src/services/reply-markers.ts
-const PROCESS_TAG = "[-process-]";
-const FINAL_TAG = "[-final-]";
-const EDGE_WS = /^[ \t\r\n]+|[ \t\r\n]+$/g;
-/** 取最终答案：去掉那一个 [-final-]（开头/中间/结尾都行），其余原样，首尾空白清掉。
-*  没有 [-final-] 返回 null。多处出现取最后一个当信号。 */
-function extractFinal(text) {
-	if (!text) return null;
-	const i = text.lastIndexOf(FINAL_TAG);
-	if (i < 0) return null;
-	return (text.slice(0, i) + text.slice(i + 9)).replace(EDGE_WS, "");
-}
-/** 剥掉一个标记 token（[-process-] 或 [-final-]，位置无关，取最后一个），其余原样，首尾空白清掉。 */
-function stripOneMarker(text) {
-	if (!text) return "";
-	const pi = text.lastIndexOf(PROCESS_TAG);
-	const fi = text.lastIndexOf(FINAL_TAG);
-	if (pi < 0 && fi < 0) return text.replace(EDGE_WS, "");
-	const [i, len] = fi >= pi ? [fi, 9] : [pi, 11];
-	return (text.slice(0, i) + text.slice(i + len)).replace(EDGE_WS, "");
-}
-/** 去掉流式途中末尾未闭合的半截标记（如 "[-fin"，缺右 "]"）。完整标记交给上面两个函数。 */
-function stripPartialTail(text) {
-	if (!text) return "";
-	return text.replace(/\[-[a-z]*-?$/i, "");
-}
-/** 定稿用：有 [-final-] 去掉它；否则剥一个标记。正文不动。 */
-function finalClean(text) {
-	return extractFinal(text) ?? stripOneMarker(text);
-}
-/** 流式展示用：有 [-final-] 直接显示最终答案；否则剥一个标记 + 半截标记，正文不动。 */
-function displayClean(text) {
-	const fin = extractFinal(text);
-	return fin !== null ? fin : stripPartialTail(stripOneMarker(text));
-}
-//#endregion
 //#region src/reply-dispatcher.ts
 const { createReplyPrefixOptions, createTypingCallbacks, logTypingFailure } = await import("openclaw/plugin-sdk/channel-runtime");
 function createDingtalkReplyDispatcher(params) {
@@ -265,24 +229,33 @@ function createDingtalkReplyDispatcher(params) {
 	let lastAnswerText = "";
 	let processMarkerLogged = false;
 	let finalMarkerLogged = false;
+	let markerSystemActive = false;
 	const observeReply = (raw, isReasoning) => {
 		const text = raw ?? "";
 		if (!text) return;
-		if (!processMarkerLogged && text.includes("[-process-]")) {
-			processMarkerLogged = true;
-			log.info(`[DingTalk][marker] 检测到过程标记 ${PROCESS_TAG}（已剥离，不展示给用户）`);
-		}
-		const fin = extractFinal(text);
-		if (fin !== null) {
+		const headTag = text.startsWith("[-final-]") ? "final" : text.startsWith("[-process-]") ? "process" : null;
+		const tailTag = text.endsWith("[-final-]") ? "final" : text.endsWith("[-process-]") ? "process" : null;
+		const abnormal = headTag !== null && tailTag !== null && headTag !== tailTag;
+		if (!abnormal && (headTag === "final" || tailTag === "final")) {
 			if (!finalMarkerLogged) {
 				finalMarkerLogged = true;
-				log.info(`[DingTalk][marker] 检测到最终标记 ${FINAL_TAG}（已剥离，以其后内容为最终答案）`);
+				log.info(`[DingTalk][marker] 检测到最终标记 ${FINAL_TAG}（头尾），标记系统激活，跳过 OpenClaw 默认兜底`);
 			}
-			finalMarkedText = fin;
+			finalMarkedText = extractFinal(text);
+			markerSystemActive = true;
+			return;
+		}
+		if (!abnormal && (headTag === "process" || tailTag === "process")) {
+			if (!processMarkerLogged) {
+				processMarkerLogged = true;
+				log.info(`[DingTalk][marker] 检测到过程标记 ${PROCESS_TAG}（头尾），标记系统激活，抑制 OpenClaw 默认兜底`);
+			}
+			markerSystemActive = true;
+			return;
 		}
-		if (!isReasoning && text.trim()) lastAnswerText = text;
+		if (!markerSystemActive && !isReasoning && text.trim()) lastAnswerText = text;
 	};
-	const pickFinalText = () => finalMarkedText ?? (lastAnswerText || accumulatedText);
+	const pickFinalText = () => markerSystemActive ? finalMarkedText ?? accumulatedText : lastAnswerText || accumulatedText;
 	const applyReplyTemplate = async (text) => {
 		try {
 			const runner = getGlobalHookRunner?.();
@@ -511,6 +484,7 @@ function createDingtalkReplyDispatcher(params) {
 			lastAnswerText = "";
 			processMarkerLogged = false;
 			finalMarkerLogged = false;
+			markerSystemActive = false;
 			if (streamingEnabled) startStreaming();
 			typingCallbacks.onActive?.();
 		},

package/dist/{messaging-B6l1sRvX.mjs → messaging-CBQl0D00.mjs}

@@ -3,6 +3,49 @@ import { n as createLoggerFromConfig } from "./logger-mZ9OSbmD.mjs";
 import { t as dingtalkHttp } from "./http-client-DFWZgO1n.mjs";
 import { i as getOapiAccessToken, r as getAccessToken, t as DINGTALK_API } from "./utils-CIfI_3Jh.mjs";
 import { r as MEDIA_MSG_TYPES } from "./session-DJ4jYqPv.mjs";
+//#region src/services/reply-markers.ts
+const PROCESS_TAG = "[-process-]";
+const FINAL_TAG = "[-final-]";
+const EDGE_WS = /^[ \t\r\n]+|[ \t\r\n]+$/g;
+/** 取最终答案：只剥头尾的 [-final-]，中间的保留。
+*  头尾都没有 [-final-] → null（不是最终答案）。
+*  剥完头尾 final 后若另一端仍是 [-process-]（如 [-process-]X[-final-]）→ 异常，返回 null 走兜底。 */
+function extractFinal(text) {
+	if (!text) return null;
+	const headIsFinal = text.startsWith(FINAL_TAG);
+	const tailIsFinal = text.endsWith(FINAL_TAG);
+	if (!headIsFinal && !tailIsFinal) return null;
+	let result = text;
+	if (headIsFinal) result = result.slice(9);
+	if (tailIsFinal) result = result.slice(0, -9);
+	if (result.startsWith("[-process-]") || result.endsWith("[-process-]")) return null;
+	return result.replace(EDGE_WS, "");
+}
+/** 剥掉开头和结尾的一个标记 token（[-process-] 或 [-final-]，头尾优先，中间的保留）。 */
+function stripOneMarker(text) {
+	if (!text) return "";
+	let result = text;
+	if (result.startsWith("[-process-]")) result = result.slice(11);
+	else if (result.startsWith("[-final-]")) result = result.slice(9);
+	if (result.endsWith("[-process-]")) result = result.slice(0, -11);
+	else if (result.endsWith("[-final-]")) result = result.slice(0, -9);
+	return result.replace(EDGE_WS, "");
+}
+/** 去掉流式途中末尾未闭合的半截标记（如 "[-fin"，缺右 "]"）。完整标记交给上面两个函数。 */
+function stripPartialTail(text) {
+	if (!text) return "";
+	return text.replace(/\[-[a-z]*-?$/i, "");
+}
+/** 定稿用：剥掉头尾各一个标记（final 或 process），中间的保留。正文不动。 */
+function finalClean(text) {
+	return stripOneMarker(text);
+}
+/** 流式展示用：有 [-final-] 直接显示最终答案；否则剥一个标记 + 半截标记，正文不动。 */
+function displayClean(text) {
+	const fin = extractFinal(text);
+	return fin !== null ? fin : stripPartialTail(stripOneMarker(text));
+}
+//#endregion
 //#region src/services/messaging/card.ts
 const _activeCardRegistry = /* @__PURE__ */ new Map();
 function registerActiveCard(openConversationId, card) {
@@ -225,15 +268,11 @@ async function ensureValidToken(card, config) {
 * 遇到 QpsLimit 错误时自动退避 2 秒后重试一次。
 */
 async function streamAICard(card, content, finished = false, config, log, contentVar) {
-	const hadMarker = content.includes("[-process-]") || content.includes("[-final-]");
-	let finalContent = content;
-	if (hadMarker) {
-		const i = content.lastIndexOf("[-final-]");
-		finalContent = i >= 0 ? content.slice(i + 9) : content;
-		finalContent = finalContent.split("[-process-]").join("").split("[-final-]").join("").replace(/^[ \t\r\n]+/, "");
-		log?.info?.(`[DingTalk][marker] ${finished ? "finishAICard" : "streamAICard"} 检测到标记，已剥离（${content.length}→${finalContent.length} 字）`);
+	if (content.includes("[-process-]") || content.includes("[-final-]")) {
+		const cleaned = finalClean(content);
+		log?.info?.(`[DingTalk][marker] ${finished ? "finishAICard" : "streamAICard"} 检测到标记，已剥离（${content.length}→${cleaned.length} 字）`);
+		content = cleaned;
 	}
-	content = finalContent;
 	const varName = contentVar || config?.cardProcessVar || config?.cardContentVar || DEFAULT_CARD_CONTENT_VAR;
 	if (!card) {
 		log?.warn?.(`[DingTalk][AICard] streamAICard 收到 null card，跳过更新`);
@@ -1041,4 +1080,4 @@ async function sendProactiveInternal(config, target, content, options) {
 	}
 }
 //#endregion
-export { sendTextMessage as a, prepareMultiBotMentions as c, getActiveCardForConversation as d, isQpsLimitError as f, unregisterActiveCard as h, sendProactive as i, createAICardForTarget as l, streamAICard as m, sendMediaToDingTalk as n, sendTextToDingTalk as o, registerActiveCard as p, sendMessage as r, buildBotMentionTable as s, sendMarkdownMessage as t, finishAICard as u };
+export { PROCESS_TAG as _, sendTextMessage as a, finalClean as b, prepareMultiBotMentions as c, getActiveCardForConversation as d, isQpsLimitError as f, FINAL_TAG as g, unregisterActiveCard as h, sendProactive as i, createAICardForTarget as l, streamAICard as m, sendMediaToDingTalk as n, sendTextToDingTalk as o, registerActiveCard as p, sendMessage as r, buildBotMentionTable as s, sendMarkdownMessage as t, finishAICard as u, displayClean as v, extractFinal as y };

package/dist/{runtime-DUgpo5zC.mjs → runtime-5-KOSMI9.mjs}

@@ -3,7 +3,7 @@ import { a as resolveDingtalkAccount, c as addWildcardAllowFrom, d as hasConfigu
 import { t as createLogger } from "./logger-mZ9OSbmD.mjs";
 import { t as dingtalkHttp } from "./http-client-DFWZgO1n.mjs";
 import "./utils-CIfI_3Jh.mjs";
-import { d as getActiveCardForConversation, n as sendMediaToDingTalk, o as sendTextToDingTalk } from "./messaging-B6l1sRvX.mjs";
+import { b as finalClean, d as getActiveCardForConversation, n as sendMediaToDingTalk, o as sendTextToDingTalk } from "./messaging-CBQl0D00.mjs";
 import { createRequire } from "node:module";
 import { z, z as z$1 } from "zod";
 //#region src/secret-input.ts
@@ -919,7 +919,7 @@ async function monitorDingtalkProvider(opts = {}) {
 	const log = createLogger(cfg.channels?.["dingtalk-connector"]?.debug ?? false);
 	const [accountsModule, monitorAccountModule, monitorSingleModule] = await Promise.all([
 		import("./accounts-BQptOmgB.mjs"),
-		import("./message-handler-DESzFFDc.mjs"),
+		import("./message-handler-CqC0-7FJ.mjs"),
 		import("./connection-DHHFFNQJ.mjs")
 	]);
 	const { resolveDingtalkAccount, listEnabledDingtalkAccounts } = accountsModule;
@@ -1199,9 +1199,7 @@ const dingtalkPlugin = {
 				...account.clientSecret != null ? { clientSecret: account.clientSecret } : {}
 			};
 			if (text && (text.includes("[-process-]") || text.includes("[-final-]"))) {
-				const i = text.lastIndexOf("[-final-]");
-				let cleaned = i >= 0 ? text.slice(i + 9) : text;
-				cleaned = cleaned.split("[-process-]").join("").split("[-final-]").join("").replace(/^[ \t\r\n]+/, "");
+				const cleaned = finalClean(text);
 				createLogger(account.config?.debug ?? false, "DingTalk:SendText").info(`[DingTalk][marker] sendText 检测到标记，已剥离（${text.length}→${cleaned.length} 字）`);
 				text = cleaned;
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jeik/dingtalk-connector",
-  "version": "0.8.21-fix2",
+  "version": "0.8.21-fix4",
   "description": "OpenClaw DingTalk channel plugin (fork) | 钉钉 OpenClaw 渠道插件（fork 自官方，含标记/卡片渲染修复）",
   "type": "module",
   "exports": {

package/src/channel.ts

@@ -30,6 +30,7 @@ import { dingtalkOnboardingAdapter } from "./onboarding.ts";
 import { monitorDingtalkProvider } from "./core/provider.ts";
 import { sendTextToDingTalk, sendMediaToDingTalk } from "./services/messaging/index.ts";
 import { getActiveCardForConversation } from "./services/messaging/card.ts";
+import { finalClean } from "./services/reply-markers.ts";
 import type { ResolvedDingtalkAccount, DingtalkConfig } from "./types/index.ts";
 
 /** Channel identifier used across the plugin. Single source of truth. */
@@ -337,11 +338,9 @@ export const dingtalkPlugin: ChannelPlugin<ResolvedDingtalkAccount> = {
         ...(account.clientSecret != null ? { clientSecret: account.clientSecret } : {}),
       };
 
-      // marker 剥离（非流式 / 无 AI Card 路径）：带标记 → 取最终答案 + 剥离
+      // marker 剥离（非流式 / 无 AI Card 路径）：只剥头尾标记，中间的保留（agent 解释标记用）
       if (text && (text.includes("[-process-]") || text.includes("[-final-]"))) {
-        const i = text.lastIndexOf("[-final-]");
-        let cleaned = i >= 0 ? text.slice(i + "[-final-]".length) : text;
-        cleaned = cleaned.split("[-process-]").join("").split("[-final-]").join("").replace(/^[ \t\r\n]+/, "");
+        const cleaned = finalClean(text);
         createLogger(account.config?.debug ?? false, 'DingTalk:SendText')
           .info(`[DingTalk][marker] sendText 检测到标记，已剥离（${text.length}→${cleaned.length} 字）`);
         text = cleaned;

package/src/reply-dispatcher.ts

@@ -115,27 +115,53 @@ export function createDingtalkReplyDispatcher(params: CreateDingtalkReplyDispatc
   let processMarkerLogged = false;
   let finalMarkerLogged = false;
 
-  // 观察每段到达的文本，更新两个认定源，并在首次检测到标记时打日志（用户无感，仅日志可见）。
+  // 观察每段到达的文本，更新标记认定状态。
+  // 标记系统激活规则：
+  //   [-final-] 出现在头/尾 → 直接认定为最终答案，跳过 OpenClaw 兜底
+  //   [-process-] 出现在头/尾 → 抑制 OpenClaw 的最终答案判定，防止中间过程被误判，流式继续渲染
+  //   无标记 / 头尾标记类型不同 → 走 OpenClaw 默认兜底
+  let markerSystemActive = false;
+
   const observeReply = (raw: string | undefined, isReasoning: boolean | undefined) => {
     const text = raw ?? "";
     if (!text) return;
-    if (!processMarkerLogged && text.includes(PROCESS_TAG)) {
-      processMarkerLogged = true;
-      log.info(`[DingTalk][marker] 检测到过程标记 ${PROCESS_TAG}（已剥离，不展示给用户）`);
-    }
-    const fin = extractFinal(text);
-    if (fin !== null) {
+
+    const headTag = text.startsWith(FINAL_TAG) ? "final" : text.startsWith(PROCESS_TAG) ? "process" : null;
+    const tailTag = text.endsWith(FINAL_TAG) ? "final" : text.endsWith(PROCESS_TAG) ? "process" : null;
+    // 异常：头尾标记类型不同（如 [-process-]…[-final-]）→ 不激活标记系统，按普通文本走 OpenClaw 兜底
+    const abnormal = headTag !== null && tailTag !== null && headTag !== tailTag;
+
+    // [-final-] 在头/尾（非异常）→ 标记系统激活，提取最终答案，跳过 OpenClaw 兜底
+    if (!abnormal && (headTag === "final" || tailTag === "final")) {
       if (!finalMarkerLogged) {
         finalMarkerLogged = true;
-        log.info(`[DingTalk][marker] 检测到最终标记 ${FINAL_TAG}（已剥离，以其后内容为最终答案）`);
+        log.info(`[DingTalk][marker] 检测到最终标记 ${FINAL_TAG}（头尾），标记系统激活，跳过 OpenClaw 默认兜底`);
+      }
+      finalMarkedText = extractFinal(text);
+      markerSystemActive = true;
+      return;
+    }
+
+    // [-process-] 在头/尾（非异常）→ 标记系统激活，抑制 OpenClaw 默认兜底
+    if (!abnormal && (headTag === "process" || tailTag === "process")) {
+      if (!processMarkerLogged) {
+        processMarkerLogged = true;
+        log.info(`[DingTalk][marker] 检测到过程标记 ${PROCESS_TAG}（头尾），标记系统激活，抑制 OpenClaw 默认兜底`);
       }
-      finalMarkedText = fin;                                 // 取最后一个 [-final-] 之后内容
+      markerSystemActive = true;
+      return;
     }
-    if (!isReasoning && text.trim()) lastAnswerText = text;  // 非思考过程 = 正式答案
+
+    // 无头尾标记 或 头尾标记异常：标记系统未激活时走 OpenClaw 兜底（标记由 finalClean 善后剥离）
+    // 已激活则保持沉默，让标记系统独占最终答案判定
+    if (!markerSystemActive && !isReasoning && text.trim()) lastAnswerText = text;
   };
 
-  // 选定本轮最终答案：优先 marker，其次最近的非 reasoning 答案，最后退回 accumulatedText。
-  const pickFinalText = (): string => finalMarkedText ?? (lastAnswerText || accumulatedText);
+  // 选定本轮最终答案：
+  //   标记系统激活 → finalMarkedText（[-final-] 在头/尾）优先，accumulatedText 流式兜底（跳过 OpenClaw）
+  //   未激活（无标记 / 头尾异常）→ lastAnswerText（OpenClaw isReasoning 兜底），accumulatedText 兜底
+  const pickFinalText = (): string =>
+    markerSystemActive ? (finalMarkedText ?? accumulatedText) : (lastAnswerText || accumulatedText);
 
   // 对最终答案套用 prompt-rewriter 的固定模板（跑 reply_payload_sending 钩子）。失败不阻断投递。
   const applyReplyTemplate = async (text: string): Promise<string> => {
@@ -529,6 +555,7 @@ export function createDingtalkReplyDispatcher(params: CreateDingtalkReplyDispatc
         lastAnswerText = "";
         processMarkerLogged = false;
         finalMarkerLogged = false;
+        markerSystemActive = false;
         if (streamingEnabled) {
           // fire-and-forget：提前创建 AI Card，onPartialReply 会等待创建完成
           void startStreaming();

package/src/services/messaging/card.ts

@@ -6,6 +6,7 @@
 import type { DingtalkConfig } from "../../types/index.ts";
 import { DINGTALK_API, getAccessToken } from "../../utils/token.ts";
 import { dingtalkHttp } from "../../utils/http-client.ts";
+import { FINAL_TAG, PROCESS_TAG, finalClean } from "../reply-markers.ts";
 
 // ============ 全局 AI Card 活跃注册表 ============
 // 用于让 outbound.sendText（message 工具）能感知当前会话是否有活跃的 AI Card，
@@ -372,15 +373,11 @@ export async function streamAICard(
 ): Promise<void> {
   // marker 剥离：所有卡片写入都经过这里，是钉钉侧的单一 chokepoint。
   // 带标记 → 提取最终答案 + 剥离；不带 → 原样。
-  const hadMarker = content.includes("[-process-]") || content.includes("[-final-]");
-  let finalContent = content;
-  if (hadMarker) {
-    const i = content.lastIndexOf("[-final-]");
-    finalContent = i >= 0 ? content.slice(i + "[-final-]".length) : content;
-    finalContent = finalContent.split("[-process-]").join("").split("[-final-]").join("").replace(/^[ \t\r\n]+/, "");
-    log?.info?.(`[DingTalk][marker] ${finished ? "finishAICard" : "streamAICard"} 检测到标记，已剥离（${content.length}→${finalContent.length} 字）`);
+  if (content.includes(PROCESS_TAG) || content.includes(FINAL_TAG)) {
+    const cleaned = finalClean(content);
+    log?.info?.(`[DingTalk][marker] ${finished ? "finishAICard" : "streamAICard"} 检测到标记，已剥离（${content.length}→${cleaned.length} 字）`);
+    content = cleaned;
   }
-  content = finalContent;
 
   const varName = contentVar
     || (config?.cardProcessVar as string)

package/src/services/reply-markers.ts

@@ -1,55 +1,65 @@
-// 回复标记工具 —— 配合 prompt-rewriter 插件注入的"打标记"指令使用。
-//
-// 【单标记方案，位置无关】指令要求每条消息【末尾】加标记（过程 [-process-]、最终答案 [-final-]，整轮一个），
-// 但模型常把标记放开头。所以提取/剥离都【不依赖位置】：只删那一个标记 token，其余原样。
-//   最终答案 = 带 [-final-] 的那条消息去掉该标记后的内容。
-//   正文里其它同名字面量（模型解释标记时）原样保留——只动作为信号的那一个。
-//
-// ⚠️ 标记字面量与逻辑必须与 prompt-rewriter 的 rewriter.ts 保持一致（两处重复，改一处要同步另一处）。
-
-export const PROCESS_TAG = "[-process-]";
-export const FINAL_TAG = "[-final-]";
-
-const EDGE_WS = /^[ \t\r\n]+|[ \t\r\n]+$/g;
-
-/** 文本里是否带任一标记（用于"带标记走记号规则 / 不带走兜底"的分流判断）。 */
-export function hasMarkers(text: string | undefined | null): boolean {
-  if (!text) return false;
-  return text.includes(PROCESS_TAG) || text.includes(FINAL_TAG);
-}
-
-/** 取最终答案：去掉那一个 [-final-]（开头/中间/结尾都行），其余原样，首尾空白清掉。
- *  没有 [-final-] 返回 null。多处出现取最后一个当信号。 */
-export function extractFinal(text: string | undefined | null): string | null {
-  if (!text) return null;
-  const i = text.lastIndexOf(FINAL_TAG);
-  if (i < 0) return null;
-  return (text.slice(0, i) + text.slice(i + FINAL_TAG.length)).replace(EDGE_WS, "");
-}
-
-/** 剥掉一个标记 token（[-process-] 或 [-final-]，位置无关，取最后一个），其余原样，首尾空白清掉。 */
-export function stripOneMarker(text: string | undefined | null): string {
-  if (!text) return "";
-  const pi = text.lastIndexOf(PROCESS_TAG);
-  const fi = text.lastIndexOf(FINAL_TAG);
-  if (pi < 0 && fi < 0) return text.replace(EDGE_WS, "");
-  const [i, len] = fi >= pi ? [fi, FINAL_TAG.length] : [pi, PROCESS_TAG.length];
-  return (text.slice(0, i) + text.slice(i + len)).replace(EDGE_WS, "");
-}
-
-/** 去掉流式途中末尾未闭合的半截标记（如 "[-fin"，缺右 "]"）。完整标记交给上面两个函数。 */
-export function stripPartialTail(text: string | undefined | null): string {
-  if (!text) return "";
-  return text.replace(/\[-[a-z]*-?$/i, "");
-}
-
-/** 定稿用：有 [-final-] 去掉它；否则剥一个标记。正文不动。 */
-export function finalClean(text: string | undefined | null): string {
-  return extractFinal(text) ?? stripOneMarker(text);
-}
-
-/** 流式展示用：有 [-final-] 直接显示最终答案；否则剥一个标记 + 半截标记，正文不动。 */
-export function displayClean(text: string | undefined | null): string {
-  const fin = extractFinal(text);
-  return fin !== null ? fin : stripPartialTail(stripOneMarker(text));
-}
+// 回复标记工具 —— 配合 prompt-rewriter 插件注入的"打标记"指令使用。
+//
+// 【头尾标记方案】只 stripping 文本【开头】和【结尾】的标记 token，中间的保留。
+// 原因：agent 可能在正文中解释标记含义，这些解释性的标记不能删。
+//   最终答案 = 去掉开头/结尾的 [-final-] 后的内容。
+//   没有 [-final-] 在头尾 → 返回 null（表示不是最终答案）。
+//
+// ⚠️ 标记字面量与逻辑必须与 prompt-rewriter 的 rewriter.ts 保持一致（两处重复，改一处要同步另一处）。
+
+export const PROCESS_TAG = "[-process-]";
+export const FINAL_TAG = "[-final-]";
+
+const EDGE_WS = /^[ \t\r\n]+|[ \t\r\n]+$/g;
+
+/** 取最终答案：只剥头尾的 [-final-]，中间的保留。
+ *  头尾都没有 [-final-] → null（不是最终答案）。
+ *  剥完头尾 final 后若另一端仍是 [-process-]（如 [-process-]X[-final-]）→ 异常，返回 null 走兜底。 */
+export function extractFinal(text: string | undefined | null): string | null {
+  if (!text) return null;
+  const headIsFinal = text.startsWith(FINAL_TAG);
+  const tailIsFinal = text.endsWith(FINAL_TAG);
+  if (!headIsFinal && !tailIsFinal) return null;
+  let result = text;
+  if (headIsFinal) result = result.slice(FINAL_TAG.length);
+  if (tailIsFinal) result = result.slice(0, -FINAL_TAG.length);
+  // 头尾混入 process（标记类型不同）→ 异常，不认定为最终答案
+  if (result.startsWith(PROCESS_TAG) || result.endsWith(PROCESS_TAG)) return null;
+  return result.replace(EDGE_WS, "");
+}
+
+/** 剥掉开头和结尾的一个标记 token（[-process-] 或 [-final-]，头尾优先，中间的保留）。 */
+export function stripOneMarker(text: string | undefined | null): string {
+  if (!text) return "";
+  let result = text;
+  // Strip start: process or final
+  if (result.startsWith(PROCESS_TAG)) {
+    result = result.slice(PROCESS_TAG.length);
+  } else if (result.startsWith(FINAL_TAG)) {
+    result = result.slice(FINAL_TAG.length);
+  }
+  // Strip end: process or final
+  if (result.endsWith(PROCESS_TAG)) {
+    result = result.slice(0, -PROCESS_TAG.length);
+  } else if (result.endsWith(FINAL_TAG)) {
+    result = result.slice(0, -FINAL_TAG.length);
+  }
+  return result.replace(EDGE_WS, "");
+}
+
+/** 去掉流式途中末尾未闭合的半截标记（如 "[-fin"，缺右 "]"）。完整标记交给上面两个函数。 */
+export function stripPartialTail(text: string | undefined | null): string {
+  if (!text) return "";
+  return text.replace(/\[-[a-z]*-?$/i, "");
+}
+
+/** 定稿用：剥掉头尾各一个标记（final 或 process），中间的保留。正文不动。 */
+export function finalClean(text: string | undefined | null): string {
+  return stripOneMarker(text);
+}
+
+/** 流式展示用：有 [-final-] 直接显示最终答案；否则剥一个标记 + 半截标记，正文不动。 */
+export function displayClean(text: string | undefined | null): string {
+  const fin = extractFinal(text);
+  return fin !== null ? fin : stripPartialTail(stripOneMarker(text));
+}

package/dist/gateway-methods-Ci31A3vg.mjs

@@ -1,2 +0,0 @@
-import { t as registerGatewayMethods } from "./gateway-methods-C4tcgI7P.mjs";
-export { registerGatewayMethods };