palz-connector 1.5.9 → 1.6.0

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "palz-connector",
   "name": "Palz Connector Channel",
-  "version": "1.5.9",
+  "version": "1.6.0",
   "description": "Palz IM 接入 OpenClaw",
   "channels": [
     "palz-connector"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palz-connector",
-  "version": "1.5.9",
+  "version": "1.6.0",
   "type": "module",
   "main": "index.js",
   "description": "Palz IM 接入 OpenClaw — 模块化架构，基于 OpenClaw Runtime 消息管道",

package/src/bot.js

@@ -29,6 +29,61 @@ function extractPlainText(content) {
     }
     return "";
 }
+// ============ 风控重生成 ============
+/** 命中内容风控（80001）后，最多重新生成回复的次数；用尽后发送兜底文案。 */
+const MAX_RISK_REGEN = 2;
+/** 重生成多次仍被风控时，发给用户的固定兜底文案。 */
+const RISK_CONTROL_FALLBACK_TEXT = "抱歉，这个话题我不太方便展开，我们聊点别的吧～";
+/**
+ * 清理风控原始错误：移除 requestid / tcloudapirequestid 等链路噪声、截断长度。
+ * 不依赖腾讯错误格式做强解析，只做低风险清理，剩余文本整段交给 agent 自行判断敏感点。
+ */
+function summarizeRiskError(rawError) {
+    return (rawError ?? "")
+        // 先 redact tcloudapirequestid，再 redact requestid，避免后者的子串匹配漏掉前者
+        .replace(/tcloudapirequestid:[^|)\s]+/gi, "tcloudapirequestid:<redacted>")
+        .replace(/requestid:[^|)\s]+/gi, "requestid:<redacted>")
+        .trim()
+        .slice(0, 500);
+}
+/**
+ * 构建"风控重生成"的 inbound context：在原始用户任务基础上追加风控纠偏指令，
+ * 复用同一 SessionKey 延续会话；用新的 MessageSid（_regen_N）避开去重。
+ *
+ * 安全：regenBody 可能含被拦内容，但它只进 ctx.Body（agent 输入），不进 IM send。
+ */
+function buildRegenerateCtx(core, baseCtx, attempt, rawError) {
+    const reason = summarizeRiskError(rawError);
+    // 取干净的当前用户消息作为原始任务（BodyForAgent 不含群聊历史），避免 agent 跑偏。
+    const originalTask = typeof baseCtx.BodyForAgent === "string" && baseCtx.BodyForAgent.trim()
+        ? baseCtx.BodyForAgent
+        : typeof baseCtx.RawBody === "string"
+            ? baseCtx.RawBody
+            : "";
+    const regenBody = [
+        "[系统提示·风控重写] 你上一条回复被平台内容风控拦截，未送达用户，需要你重新生成。",
+        originalTask ? `原始用户任务：\n${originalTask}` : "",
+        reason
+            ? `平台返回的错误信息如下，请据此判断是哪部分内容触发了风控并规避：\n${reason}`
+            : "平台返回错误码 80001（内容风控）。",
+        "要求：保持你原本想表达的核心意思和有用信息，换一种措辞重写，避开上述触发风控的内容（包括其谐音、拼音、缩写、变体）；",
+        "如果该信息无法在不触及敏感内容的前提下表达，则改为简短地说明这部分内容不便展开。",
+        "直接输出重写后的新回复，不要解释你在重写、也不要复述本提示。",
+    ]
+        .filter(Boolean)
+        .join("\n");
+    // 注意：finalizeInboundContext 会 mutate 入参对象，必须用 {...baseCtx} 展开成新对象，
+    // 绝不能直接传 baseCtx —— 否则会污染原始 ctx，导致下一轮 originalTask 被本轮 regenBody 覆盖。
+    return core.channel.reply.finalizeInboundContext({
+        ...baseCtx,
+        Body: regenBody,
+        BodyForAgent: regenBody,
+        RawBody: regenBody,
+        CommandBody: "",
+        MessageSid: `${baseCtx.MessageSid}_regen_${attempt}`,
+        Timestamp: Date.now(),
+    });
+}
 // ============ reasoning 激活状态缓存（内存） ============
 const REASONING_ACTIVATE_TTL_MS = 15 * 60 * 1000; // 15 分钟
 /** 已激活 reasoning stream 的 session key → 激活时间戳(ms)，超过 TTL 后重新发送激活指令 */
@@ -370,6 +425,7 @@ async function dispatchPalzMessage(params) {
 async function _dispatchPalzMessageInner(params) {
     const { cfg, msg, runtime, accountId, agentId } = params;
     const log = typeof runtime?.log === "function" ? runtime.log : console.log;
+    const error = typeof runtime?.error === "function" ? runtime.error : console.error;
     const tag = `palz[${accountId}]`;
     const core = getPalzRuntime();
     const account = resolvePalzAccount({ cfg, accountId });
@@ -679,7 +735,8 @@ async function _dispatchPalzMessageInner(params) {
     const step6c = `[STEP 6c 创建dispatcher] 输入: ${JSON.stringify(dispatcherParams)}`;
     log(`${tag}: ${step6c}`);
     span?.addEvent(step6c);
-    const { dispatcher, replyOptions, markDispatchIdle } = createPalzReplyDispatcher({
+    // 每轮重生成都需要一个全新的 dispatcher 实例（riskControl 状态随实例重置），抽成工厂。
+    const makeDispatcher = () => createPalzReplyDispatcher({
         cfg,
         accountId,
         runtime,
@@ -696,24 +753,78 @@ async function _dispatchPalzMessageInner(params) {
         sessionKey: route.sessionKey,
         passthrough: buildPassthroughFromMsg(msg),
     });
-    // STEP 6d: 分发消息给 AI
+    // STEP 6d: 分发消息给 AI（带风控重生成循环）
     // channel registry 守卫已在 index.ts 中通过 defineProperty 安装，
     // 每次读取 state.registry 时会自动注入 palz-connector channel。
     const step6dStart = `[STEP 6d AI分发] 开始 session=${route.sessionKey} stream=${useStream}`;
     log(`${tag}: ${step6dStart}`);
     span?.addEvent(step6dStart);
     const dispatchStartMs = Date.now();
-    const { queuedFinal, counts } = await core.channel.reply.withReplyDispatcher({
-        dispatcher,
-        onSettled: () => markDispatchIdle(),
-        run: () => core.channel.reply.dispatchReplyFromConfig({
-            ctx,
-            cfg,
+    let queuedFinal = false;
+    let counts = {};
+    let attempt = 0; // 已重生成次数
+    let currentCtx = ctx; // 第 0 轮用原始 ctx，之后用 buildRegenerateCtx 产物
+    let lastRiskError;
+    let blockedByRiskControl = false; // 最近一轮是否仍被风控拦截
+    while (true) {
+        const { dispatcher, replyOptions, markDispatchIdle, riskControl } = makeDispatcher();
+        const result = await core.channel.reply.withReplyDispatcher({
             dispatcher,
-            replyOptions,
-        }),
-    });
+            onSettled: () => markDispatchIdle(),
+            run: () => core.channel.reply.dispatchReplyFromConfig({
+                ctx: currentCtx,
+                cfg,
+                dispatcher,
+                replyOptions,
+            }),
+        });
+        queuedFinal = result.queuedFinal;
+        counts = result.counts;
+        // withReplyDispatcher 返回时 sendChain（含 HTTP send）已 settle，风控结果已确定。
+        if (!riskControl.hit) {
+            blockedByRiskControl = false;
+            break; // 未触发风控 → 正常完成
+        }
+        blockedByRiskControl = true;
+        lastRiskError = riskControl.rawError;
+        if (attempt >= MAX_RISK_REGEN) {
+            // 重生成次数已用尽，跳出走兜底
+            log(`${tag}: [RISK_CONTROL] 已重生成 ${attempt} 次仍被风控, 停止重试`);
+            span?.addEvent(`[RISK_CONTROL] exhausted after attempt=${attempt}`);
+            break;
+        }
+        attempt++;
+        log(`${tag}: [RISK_CONTROL] 第 ${attempt} 次重生成触发 error=${lastRiskError?.slice(0, 120)}`);
+        span?.addEvent(`[RISK_CONTROL] regenerate attempt=${attempt}`);
+        // 用清理后的风控摘要 + 原始用户任务构建重生成 ctx
+        currentCtx = buildRegenerateCtx(core, ctx, attempt, lastRiskError);
+    }
+    // 兜底：重生成次数用尽仍被风控 → 直发固定文案，保证用户一定收到回复
+    if (blockedByRiskControl) {
+        log(`${tag}: [RISK_CONTROL] 重生成 ${MAX_RISK_REGEN} 次仍失败, 发送兜底文案`);
+        span?.addEvent(`[RISK_CONTROL] fallback after ${MAX_RISK_REGEN} regenerations`);
+        try {
+            await sendToPalzIM({
+                config,
+                conversationId: msg.conversation_id,
+                content: RISK_CONTROL_FALLBACK_TEXT,
+                conversationType: msg.conversation_type || "direct",
+                msgId: msg.msg_id,
+                senderId: msg.sender_id,
+                msgType: msg.msg_type,
+                groupId,
+                lobsterId: msg.lobster_id,
+                passthrough: buildPassthroughFromMsg(msg),
+                log,
+                error,
+            });
+        }
+        catch (e) {
+            error(`${tag}: [RISK_CONTROL] 兜底文案发送失败: ${String(e)}`);
+        }
+    }
     // AI 回复完成后清空群聊历史（已拼入上下文，避免下次重复）
+    // 移到重生成循环之后，只清一次，避免重生成轮次里历史被提前清空。
     if (isGroup && historyKey && groupContextCacheEnabled) {
         clearGroupHistory(historyKey, log);
     }

package/src/reply-dispatcher.js

@@ -9,7 +9,7 @@
  */
 import { getPalzRuntime } from "./runtime.js";
 import { loadMediaAsOssUrl } from "./media.js";
-import { sendToPalzIM } from "./send.js";
+import { sendToPalzIM, PalzRiskControlError } from "./send.js";
 import { resolveToolDisplay, formatToolStartText, formatToolResultText, formatResultSummary } from "./tool-display.js";
 const STREAM_THROTTLE_MS = 200;
 function createStreamingState() {
@@ -27,12 +27,36 @@ export function createPalzReplyDispatcher(params) {
     const error = typeof runtime?.error === "function" ? runtime.error : console.error;
     const streamState = enableStreaming ? createStreamingState() : null;
     const tag = `palz[${accountId}]`;
+    // 风控状态（dispatcher 实例级）：当前正文回复（palzMsgType===undefined）命中腾讯
+    // 内容风控（80001）时置位，rawError 保留原始错误文案供上层回灌给 agent 做规避指引。
+    // 每个 dispatcher 实例对应一轮 dispatch，新实例自动重置。
+    const riskControl = { hit: false };
     // 会话级串行队列：保证同一会话内 IM 消息按入队顺序到达
     // (不同 dispatcher 实例对应不同会话，天然隔离)
     let imSendQueue = Promise.resolve();
     const enqueueIMSend = (content, streamOpts, palzMsgType, label) => {
-        const next = imSendQueue.then(() => sendToIM(content, streamOpts, palzMsgType)).catch((err) => {
-            error(`${tag}: [IM_QUEUE] ${label} 发送失败: ${err?.message ?? String(err)}`);
+        // palzMsgType===undefined 是当前 Palz 正文回复路径的识别条件；
+        // tool/thinking 旁路消息带非空 palzMsgType，不参与风控重生成（命中也仅打日志）。
+        const isBodyReply = palzMsgType === undefined;
+        const next = imSendQueue
+            .then(() => {
+            // 本轮正文已命中风控 → 跳过后续正文发送，避免继续外泄被拦内容（block streaming 已关，
+            // 正常只有单条 final，此处是对未来潜在多条正文的防御）。
+            if (isBodyReply && riskControl.hit) {
+                log(`${tag}: [RISK_CONTROL] 已命中风控, 跳过后续正文发送 label=${label}`);
+                return;
+            }
+            return sendToIM(content, streamOpts, palzMsgType);
+        })
+            .catch((err) => {
+            if (err instanceof PalzRiskControlError && isBodyReply) {
+                riskControl.hit = true;
+                riskControl.rawError = err.rawError;
+                error(`${tag}: [RISK_CONTROL] 正文回复触发风控(80001): ${err.rawError?.slice(0, 200)}`);
+            }
+            else {
+                error(`${tag}: [IM_QUEUE] ${label} 发送失败: ${err?.message ?? String(err)}`);
+            }
         });
         imSendQueue = next;
         return next;
@@ -193,6 +217,9 @@ export function createPalzReplyDispatcher(params) {
     });
     const palzReplyOptions = {
         ...replyOptions,
+        // 强制关闭 block streaming：让正文回复收敛为单条 final，避免"前半段已送达、
+        // 后半段被风控"的不可回滚问题，保证风控重生成语义干净（见 docs/risk-control-regenerate-plan.md §3.0）。
+        disableBlockStreaming: true,
         // 传入 runId 让 OpenClaw agent execution 使用，与 onAgentEvent 的 evt.runId 对应
         ...(toolRunId ? { runId: toolRunId } : {}),
         onPartialReply: enableStreaming
@@ -242,5 +269,5 @@ export function createPalzReplyDispatcher(params) {
             }
             : undefined,
     };
-    return { dispatcher, replyOptions: palzReplyOptions, markDispatchIdle };
+    return { dispatcher, replyOptions: palzReplyOptions, markDispatchIdle, riskControl };
 }

package/src/send.js

@@ -7,6 +7,37 @@
 import { tracer, trace, SpanStatusCode, buildTraceparentHeader } from "./tracing.js";
 import { contentPartsToOpenAIContent } from "./content.js";
 const SEND_TIMEOUT_MS = 20_000;
+/**
+ * IM 后端转调腾讯 IM SDK 时可能命中内容风控（敏感词），此时 HTTP 200 但 body
+ * `{ok:false, error:"...(code: 80001)"}`。用专用错误类型把它和普通发送失败区分开，
+ * 让上层（reply-dispatcher / bot）能据此触发"重新生成回复"。
+ */
+export class PalzRiskControlError extends Error {
+    code = 80001;
+    rawError;
+    constructor(rawError) {
+        super(`Palz risk control blocked: ${rawError}`);
+        this.name = "PalzRiskControlError";
+        this.rawError = rawError;
+    }
+}
+/** 腾讯内容风控错误码（先支持 80001 脏词，数组化便于后续扩展）。 */
+const RISK_CONTROL_CODES = [80001];
+/**
+ * 判定一个 `/bot/send` 响应 body 是否为内容风控失败。
+ * 命中返回原始 error 文案（供回灌给 agent 做规避指引），否则返回 null。
+ */
+function detectRiskControl(body) {
+    if (!body || body.ok !== false)
+        return null;
+    const err = typeof body.error === "string" ? body.error : "";
+    for (const code of RISK_CONTROL_CODES) {
+        if (err.includes(`code: ${code}`) || err.includes(`(${code})`) || body.code === code) {
+            return err || `risk control code ${code}`;
+        }
+    }
+    return null;
+}
 let msgSeq = 0;
 function nextMsgId() {
     return `bot_reply_${Date.now()}_${++msgSeq}`;
@@ -123,6 +154,16 @@ async function _sendToPalzIMInner(params) {
         span?.addEvent(failLog);
         throw new Error(`Palz send failed: ${response.status} ${rawText}`);
     }
+    // HTTP 200 但业务 ok:false 且命中风控码（80001）—— 抛专用错误供上层触发重新生成。
+    // 非风控的 ok:false 暂保持现状（往下走 return body），避免扩大改动面。
+    const riskErr = detectRiskControl(body);
+    if (riskErr) {
+        const blockLog = `[HTTP_RES] RISK_CONTROL status=${response.status} elapsed=${elapsedMs}ms code=80001 error=${riskErr.slice(0, 200)}`;
+        error(`palz-send: ${blockLog}`);
+        span?.addEvent(blockLog);
+        span?.setStatus({ code: SpanStatusCode.ERROR, message: "risk_control_80001" });
+        throw new PalzRiskControlError(riskErr);
+    }
     const okLog = `[HTTP_RES] OK status=${response.status} elapsed=${elapsedMs}ms msg_id=${resolvedMsgId}${traceparent ? ` Traceparent=${traceparent}` : ""}\n  response_body=${rawText.slice(0, 500)}`;
     log(`palz-send: ${okLog}`);
     span?.addEvent(okLog);