aitable-workflow-cli 0.1.23 → 0.1.24

package/templates/support-qa/workflows/group-qa/recipes/conversation_handler.recipe.ts

@@ -1,394 +0,0 @@
-import type {
-  EventContext,
-  EventHandlerRecipeDefinition,
-  HandlerInitContext,
-  HandlerInstance,
-} from "aitable-workflow-core";
-import {
-  formatZonedDateTime,
-  formatZonedHm,
-  normalizeTimezone,
-  resolveDingTalkStreamMessageEventContext,
-  resolveDingTalkWebhookMentionEventContext,
-  resolveGlobalVarRef,
-} from "aitable-workflow-core";
-import { z } from "zod";
-import { SUPPORT_MEMORY_KINDS, SUPPORT_MEMORY_ROLES, supportEntry, supportScope } from "../../../lib/memory-events.js";
-import { echoWindow } from "../../../lib/guards.js";
-
-/**
- * 会话消息处理器（support-qa L0）
- *
- * 事件源只产出统一的 message_received。本 handler 是长活单例：
- *   - onEvent 纯同步（无长 await）：回声过滤 → 摄入本轮消息 + 构建「近期对话上下文」→ pushEvent 建单。
- *   - 内存里按 conversationId 维护近期消息环形缓冲（容量/TTL 限制，重启清空）。
- *
- * 三处 Pattern 级行为要点：
- *   1. 出站回声防护：reply 发布的内容指纹命中 → 按机器人消息处理（只记历史不建单），
- *      防 webhook 回复以真人名义回流造成自激（评测硬用例 G1）。
- *   2. 管理员/真人同事消息写入短期记忆（role=admin）：学习通道（daily-review 提炼
- *      「提问→真人解答」）的原料，不建单不回复但必须留原料（勿删）。
- *   3. 历史消息带时间戳注入上下文：追问补位闸门（gates.standby）需要"@Owner 后已等多久"。
- *
- * 名单来源（均为 globalVar 引用，config-sync L2 装包后发布；未装包时为空集不影响 L0）：
- *   - conversation_ids → 群配置（[{groupId, botNick, corpId}]）：识别机器人自身消息，并为 Webhook @人指定群归属企业
- *   - admins           → 真人同事名单（[{nick, openDingTalkId}] 或 ["花名"]）
- */
-
-const HISTORY_CAPACITY = 20;
-const HISTORY_TTL_MS = 30 * 60 * 1000;
-const IMAGE_MARK = "![图片]";
-const CONFIG_CACHE_TTL_MS = 30 * 1000;
-const DEFAULT_AGGREGATE_WINDOW_MS = 5000;
-
-type HistoryEntry = { sender: string; openId: string; content: string; ts: number };
-type IdentitySets = { ids: Set<string>; nicks: Set<string> };
-type GroupRuntimeConfig = {
-  identity: IdentitySets;
-  outbound: string;
-  corpId: string;
-};
-type PendingMessage = { content: string; senderName: string; senderOpenId: string; sendTime: string; ts: number; messageId: string; hasImage: boolean };
-type PendingBatch = {
-  messages: PendingMessage[];
-  conversationId: string;
-  senderName: string;
-  senderOpenDingTalkId: string;
-  eventContext?: EventContext;
-  timer: ReturnType<typeof setTimeout>;
-};
-
-function parseNicks(raw: unknown): Set<string> {
-  const arr = Array.isArray(raw) ? raw.map(String) : String(raw ?? "").split(/[,，]/);
-  return new Set(arr.map((s) => s.trim()).filter(Boolean));
-}
-
-/** 先按 openDingTalkId 精确匹配，匹配不到再用花名兜底 */
-function matchesIdentity(sets: IdentitySets, sender: string, openId: string): boolean {
-  if (openId && sets.ids.has(openId)) return true;
-  return !!sender && sets.nicks.has(sender);
-}
-
-function loadGroupBots(list: unknown): Map<string, GroupRuntimeConfig> {
-  const map = new Map<string, GroupRuntimeConfig>();
-  for (const g of Array.isArray(list) ? list : []) {
-    if (!g || typeof g !== "object") continue;
-    const rec = g as Record<string, unknown>;
-    const gid = String(rec.groupId ?? "").trim();
-    if (gid) {
-      map.set(gid, {
-        identity: { ids: new Set(), nicks: parseNicks(rec.botNick) },
-        outbound: String(rec.outbound ?? "").trim(),
-        corpId: String(rec.corpId ?? "").trim(),
-      });
-    }
-  }
-  return map;
-}
-
-function loadAdmins(list: unknown): IdentitySets {
-  const ids = new Set<string>();
-  const nicks = new Set<string>();
-  for (const e of Array.isArray(list) ? list : []) {
-    if (typeof e === "string") {
-      const nick = e.trim();
-      if (nick) nicks.add(nick);
-    } else if (e && typeof e === "object") {
-      const rec = e as Record<string, unknown>;
-      const nick = String(rec.nick ?? "").trim();
-      const openId = String(rec.openDingTalkId ?? "").trim();
-      if (nick) nicks.add(nick);
-      if (openId) ids.add(openId);
-    }
-  }
-  return { ids, nicks };
-}
-
-function roleTag(sender: string, openId: string, botSets: IdentitySets, adminSets: IdentitySets): string {
-  if (matchesIdentity(botSets, sender, openId)) return "(答疑机器人/即你自己之前的回复)";
-  if (matchesIdentity(adminSets, sender, openId)) return "(真人同事)";
-  return "";
-}
-
-/** 历史时间戳格式：闸门（追问补位）据此计算等待时长。按配置时区渲染，UTC 主机上不错位 */
-function formatTs(ts: number, timezone: string): string {
-  return formatZonedHm(new Date(ts), timezone);
-}
-
-function ttlCached<T>(loader: () => T, ttlMs: number): () => T {
-  let cache: T | null = null;
-  let loadedAt = 0;
-  return () => {
-    const now = Date.now();
-    if (cache === null || now - loadedAt > ttlMs) {
-      cache = loader();
-      loadedAt = now;
-    }
-    return cache;
-  };
-}
-
-const recipe: EventHandlerRecipeDefinition = {
-  meta: {
-    id: "conversation_handler",
-    name: "会话消息处理器",
-    description: "message_received → 回声过滤 → 构建近期对话上下文 → 创建工单",
-    config: z.object({
-      conversation_ids: z
-        .union([z.string(), z.array(z.unknown())])
-        .optional()
-        .describe("群配置来源（二选一）：静态数组 [{groupId, botNick, corpId}]，或引用 ${globalVar.group_configs}（config-sync 从 AI 表格发布）。缺省取后者。识别每群机器人身份，并为 Webhook @人指定群归属企业"),
-      admins: z
-        .union([z.string(), z.array(z.unknown())])
-        .optional()
-        .describe("真人同事名单来源（二选一）：静态数组 [{nick, openDingTalkId}] 或 [\"花名\"]，或引用 ${globalVar.admins}。缺省取后者。"),
-      timezone: z
-        .string()
-        .optional()
-        .describe("对话上下文 [hh:mm] 的渲染时区（IANA，缺省 Asia/Shanghai）；UTC 主机上避免错位 8 小时"),
-      aggregate_window_ms: z
-        .number()
-        .int()
-        .min(0)
-        .optional()
-        .describe("同人同群消息聚合窗口（毫秒）。事件驱动源每条消息单独到达，该窗口内连续消息合并为一个工单。缺省 5000ms，设 0 关闭聚合。"),
-    }),
-  },
-
-  create(ctx: HandlerInitContext): HandlerInstance {
-    const histories = new Map<string, HistoryEntry[]>();
-    const emptySets: IdentitySets = { ids: new Set(), nicks: new Set() };
-    const timezone = normalizeTimezone(typeof ctx.config.timezone === "string" ? ctx.config.timezone : undefined);
-    const aggregateWindowMs = typeof ctx.config.aggregate_window_ms === "number"
-      ? ctx.config.aggregate_window_ms
-      : DEFAULT_AGGREGATE_WINDOW_MS;
-    // 两种形态都直接交给 resolveGlobalVarRef：ref 字符串被活读，静态数组原样透传。
-    // 不要套 String()：静态数组会被压成 "[object Object],..." 而后被 loader 的
-    // Array.isArray 判假，静默退化成空名单 —— 服务照常启动、日志干净、就是不干活。
-    const groupsSource = ctx.config.conversation_ids ?? "${globalVar.group_configs}";
-    const adminsSource = ctx.config.admins ?? "${globalVar.admins}";
-    const getAdmins = ttlCached(
-      () => loadAdmins(resolveGlobalVarRef(adminsSource, ctx.getGlobalVar)),
-      CONFIG_CACHE_TTL_MS,
-    );
-    const getGroupBots = ttlCached(
-      () => loadGroupBots(resolveGlobalVarRef(groupsSource, ctx.getGlobalVar)),
-      CONFIG_CACHE_TTL_MS,
-    );
-
-    const pending = new Map<string, PendingBatch>();
-
-    function flushBatch(key: string): void {
-      const batch = pending.get(key);
-      if (!batch) return;
-      pending.delete(key);
-
-      const { messages, conversationId, senderName, senderOpenDingTalkId, eventContext } = batch;
-      const mergedContent = messages.map((m) => m.content).join("\n");
-      const lastMsg = messages[messages.length - 1]!;
-
-      const adminSets = getAdmins();
-      const botSets = getGroupBots().get(conversationId)?.identity ?? emptySets;
-
-      // history 已在 onEvent 时实时写入，此处只读取构建上下文（batch 内消息已在 history 中）
-      const prior = (histories.get(conversationId) ?? []).filter((e) => lastMsg.ts - e.ts <= HISTORY_TTL_MS);
-      histories.set(conversationId, prior);
-      // 上下文排除 batch 自身的消息：只取 batch 首条之前的历史作为「当前之前」的对话上下文
-      const firstTs = messages[0]!.ts;
-      const contextEntries = prior.filter((e) => e.ts < firstTs);
-      const contextText =
-        contextEntries.length > 0
-          ? [
-              "以下是群聊中近期的对话历史(帮助理解当前问题的上下文，如追问、反馈、是否已被同事接手；[hh:mm] 为发送时间，供判断等待时长):",
-              "---",
-              ...contextEntries.map((e, i) => `[历史消息 ${i + 1}][${formatTs(e.ts, timezone)}] ${e.sender}${roleTag(e.sender, e.openId, botSets, adminSets)}: ${e.content}`),
-              "---",
-            ].join("\n")
-          : "";
-
-      ctx.log(`聚合 flush: ${senderName}@${conversationId}, ${messages.length} 条消息合并`);
-      ctx.pushEvent({
-        action: "create_record",
-        fields: {
-          "消息内容": mergedContent,
-          "发送人": senderName,
-          "发送时间": formatZonedDateTime(lastMsg.ts, timezone),
-          "群ID": conversationId,
-          "对话上下文": contextText,
-        },
-        ...(eventContext ? { eventContext } : {}),
-      });
-
-      for (const m of messages) {
-        void ctx.toolkit.memory.append(supportScope(conversationId), supportEntry({
-          timestamp: m.sendTime,
-          kind: SUPPORT_MEMORY_KINDS.userMessage,
-          content: m.content,
-          sender: m.senderName,
-          role: SUPPORT_MEMORY_ROLES.user,
-          conversationId,
-          meta: { messageId: m.messageId, hasImage: m.hasImage },
-        })).catch((err) => ctx.log(`memory.append(user_message) 失败(不影响主流程): ${err}`));
-      }
-    }
-
-    return {
-      onEvent(event) {
-        const payload = event.payload;
-        const content = String(payload.content ?? "");
-        const hasImage = content.includes(IMAGE_MARK);
-        if (!content.trim() && !hasImage) {
-          ctx.log("消息内容为空且无图片，跳过(不 push)");
-          return;
-        }
-
-        const senderName = String(payload.senderName ?? payload.sender ?? payload.firstSender ?? "");
-        const senderOpenId = String(payload.senderOpenDingTalkId ?? "").trim();
-        const messageId = String(payload.messageId ?? "");
-        const sendTime = String(payload.firstSendTime ?? new Date().toISOString());
-        const conversationId = String(payload.conversationId ?? "");
-        const now = Date.parse(sendTime) || Date.now();
-        const adminSets = getAdmins();
-        const groupConfig = getGroupBots().get(conversationId);
-        const botSets = groupConfig?.identity ?? emptySets;
-        // 出站回声：webhook 回复以真人名义回流时身份匹配失效，用内容指纹兜底（G1）
-        const isEcho = echoWindow.has(ctx.getGlobalVar, content);
-        const isBot = isEcho || matchesIdentity(botSets, senderName, senderOpenId);
-        const isAdmin = !isBot && matchesIdentity(adminSets, senderName, senderOpenId);
-
-        // 1) 取该群历史，裁剪过期，构建「当前之前」的对话上下文（带角色标记 + 时间戳）
-        const prior = (histories.get(conversationId) ?? []).filter((e) => now - e.ts <= HISTORY_TTL_MS);
-        const contextText =
-          prior.length > 0
-            ? [
-                "以下是群聊中近期的对话历史(帮助理解当前问题的上下文，如追问、反馈、是否已被同事接手；[hh:mm] 为发送时间，供判断等待时长):",
-                "---",
-                ...prior.map((e, i) => `[历史消息 ${i + 1}][${formatTs(e.ts, timezone)}] ${e.sender}${roleTag(e.sender, e.openId, botSets, adminSets)}: ${e.content}`),
-                "---",
-              ].join("\n")
-            : "";
-
-        // 2) 机器人/管理员消息立即入历史（用户消息由聚合 flush 或立即推送路径写入，避免重复）
-        if (isBot || isAdmin) {
-          prior.push({ sender: senderName, openId: senderOpenId, content, ts: now });
-          while (prior.length > HISTORY_CAPACITY) prior.shift();
-          histories.set(conversationId, prior);
-        }
-
-        // 机器人自己的消息（含回声）只记录进历史，不建单
-        if (isBot) {
-          ctx.log(`机器人消息${isEcho ? "(出站回声)" : ""}，仅记录进历史不建单: ${senderName}`);
-          return;
-        }
-
-        // 真人同事/管理员消息：不建单不回复，但必须写短期记忆（学习通道原料）
-        if (isAdmin) {
-          ctx.log(`真人同事消息，记历史+记忆不建单: ${senderName}`);
-          void ctx.toolkit.memory.append(supportScope(conversationId), supportEntry({
-            timestamp: sendTime,
-            kind: SUPPORT_MEMORY_KINDS.adminMessage,
-            content,
-            sender: senderName,
-            role: SUPPORT_MEMORY_ROLES.admin,
-            conversationId,
-            meta: { messageId, hasImage },
-          })).catch((err) => ctx.log(`memory.append(admin_message) 失败(不影响主流程): ${err}`));
-          return;
-        }
-
-        ctx.log(`处理群消息: 来自 ${senderName}${hasImage ? "(含图片)" : ""}, 历史 ${prior.length - 1} 条`);
-
-        let eventContext: EventContext | undefined;
-        const replyCtx = (payload.dingtalk ?? {}) as Record<string, unknown>;
-        if (groupConfig?.outbound === "webhook") {
-          eventContext = resolveDingTalkWebhookMentionEventContext({
-            type: "dingtalk_webhook_mention",
-            conversationId,
-            senderOpenDingTalkId: senderOpenId,
-            senderName,
-            corpId: groupConfig.corpId,
-          });
-        } else if (replyCtx.credRef) {
-          eventContext = resolveDingTalkStreamMessageEventContext({
-            type: "dingtalk_stream_message",
-            openMsgId: String(replyCtx.openMsgId ?? ""),
-            conversationId,
-            robotCode: String(replyCtx.robotCode ?? ""),
-            credRef: String(replyCtx.credRef ?? ""),
-          });
-        }
-
-        // 聚合：固定窗口，第一条消息定窗口 [now, now + aggregateWindowMs]，窗口到期统一 flush
-        if (aggregateWindowMs > 0) {
-          const aggKey = `${conversationId}::${senderOpenId || senderName}`;
-          const msg: PendingMessage = { content, senderName, senderOpenId, sendTime, ts: now, messageId, hasImage };
-          // 立即写入 history，保证窗口期间同群其他人的上下文能看到这条消息
-          prior.push({ sender: senderName, openId: senderOpenId, content, ts: now });
-          while (prior.length > HISTORY_CAPACITY) prior.shift();
-          histories.set(conversationId, prior);
-
-          const existing = pending.get(aggKey);
-          if (existing) {
-            existing.messages.push(msg);
-            if (eventContext) existing.eventContext = eventContext;
-            ctx.log(`聚合: ${senderName}@${conversationId} 追加第 ${existing.messages.length} 条`);
-          } else {
-            if (eventContext?.type === "dingtalk_stream_message") {
-              ctx.toolkit.messaging?.beginDingTalkProcessingFeedback?.(eventContext);
-            }
-            const timer = setTimeout(() => flushBatch(aggKey), aggregateWindowMs);
-            pending.set(aggKey, {
-              messages: [msg],
-              conversationId,
-              senderName,
-              senderOpenDingTalkId: senderOpenId,
-              eventContext,
-              timer,
-            });
-            ctx.log(`聚合: ${senderName}@${conversationId} 开始 ${aggregateWindowMs}ms 窗口`);
-          }
-          return;
-        }
-
-        // aggregateWindowMs === 0: 不聚合，立即推送（兼容旧行为）
-        prior.push({ sender: senderName, openId: senderOpenId, content, ts: now });
-        while (prior.length > HISTORY_CAPACITY) prior.shift();
-        histories.set(conversationId, prior);
-
-        if (eventContext?.type === "dingtalk_stream_message") {
-          ctx.toolkit.messaging?.beginDingTalkProcessingFeedback?.(eventContext);
-        }
-        ctx.pushEvent({
-          action: "create_record",
-          fields: {
-            "消息内容": content,
-            "发送人": senderName,
-            "发送时间": formatZonedDateTime(now, timezone),
-            "群ID": conversationId,
-            "对话上下文": contextText,
-          },
-          ...(eventContext ? { eventContext } : {}),
-        });
-        void ctx.toolkit.memory.append(supportScope(conversationId), supportEntry({
-          timestamp: sendTime,
-          kind: SUPPORT_MEMORY_KINDS.userMessage,
-          content,
-          sender: senderName,
-          role: SUPPORT_MEMORY_ROLES.user,
-          conversationId,
-          meta: { messageId, hasImage },
-        })).catch((err) => ctx.log(`memory.append(user_message) 失败(不影响主流程): ${err}`));
-      },
-      stop() {
-        for (const [key, batch] of pending) {
-          clearTimeout(batch.timer);
-          flushBatch(key);
-        }
-        pending.clear();
-        histories.clear();
-      },
-    };
-  },
-};
-
-export default recipe;

package/templates/support-qa/workflows/group-qa/recipes/fastpath.recipe.ts

@@ -1,72 +0,0 @@
-import { z } from "zod";
-import { type RecipeDefinition, type RecipeContext, type RecipeResult } from "aitable-workflow-core";
-import { loadReplyRules, matchReplyRules } from "../../../lib/declarative-matcher.js";
-
-/**
- * fastpath 确定性秒回（support-qa L3，group-qa 首步，非 LLM）
- *
- * 按 profile/fastpath/known-answers.yml 的声明式规则（template/contains/regex + 安全兜底）
- * 单向匹配当前消息，命中即产出「已知错误」类别的固定话术，下游 answer 透传、reply_to_group 发送。
- *
- * 关闭/透传语义：
- *   - profile.fastpath.rules 未配置或文件缺失 → 透传（本步不表态，tracker:false）；
- *   - 空消息 / 上游已定类 → 透传；
- *   - 未命中任何规则 → 透传给 answer 走语义答疑（语义匹配不属于 fastpath）。
- *
- * 命中即建行：本步返回 output（含 answer）且不置 tracker:false，on_demand 下建行留痕
- * （已知错误秒回的建行语义）。
- */
-const recipe: RecipeDefinition = {
-  meta: {
-    id: "fastpath",
-    name: "确定性秒回",
-    role: "support",
-    description: "声明式规则（template/contains/regex + 安全兜底）单向匹配秒回，非 LLM",
-    version: "1.0.0",
-    requiresAgent: false,
-    timeoutMs: 10_000,
-    config: z.object({
-      rules: z.string().optional().describe("确定性秒回规则文件路径（相对 profile 目录）；省略即关闭 fastpath"),
-    }),
-  },
-
-  async execute(ctx: RecipeContext): Promise<RecipeResult> {
-    const { input, log } = ctx;
-    const content = String(input.content ?? "");
-    const senderName = String(input.senderName ?? "").trim();
-    const priorAction = String(input.action ?? "").trim();
-
-    // 上游已产出 action（fastpath 通常是首步，此处为防御）→ 透传
-    if (priorAction) {
-      return { status: "success", output: {}, tracker: false, logs: [`透传：${priorAction}`] };
-    }
-    if (!content.trim()) {
-      return { status: "success", output: {}, tracker: false, logs: ["空消息，透传"] };
-    }
-
-    const { config, issues } = loadReplyRules(ctx.configDir, ctx.config.rules as string | undefined);
-    for (const i of issues) log(`[fastpath] ${i}`);
-    if (!config) {
-      // 未配置/文件缺失 → fastpath 关闭，透传 answer
-      return { status: "success", output: {}, tracker: false, logs: ["fastpath 未启用，透传"] };
-    }
-
-    const match = matchReplyRules(config, content);
-    if (!match) {
-      log("未命中 fastpath 规则，交给 answer");
-      return { status: "success", output: {}, tracker: false, logs: ["未命中 fastpath"] };
-    }
-
-    const greeting = senderName ? `Hi ${senderName}，` : "";
-    const answer = `${greeting}${match.reply}`;
-    log(`命中 fastpath 规则 [${match.key}]（${match.kind}），秒回`);
-    return {
-      status: "success",
-      // action=reply：下游 on_action 按 answer 策略透传，reply_to_group 沿用 @提问者
-      output: { action: "reply", answer },
-      logs: [`fastpath 命中 ${match.key}(${match.kind})`],
-    };
-  },
-};
-
-export default recipe;