@ai-setting/roy-agent-core 1.7.61 → 1.7.62

package/dist/shared/@ai-setting/roy-agent-core-9nvyffxg.js

@@ -0,0 +1,414 @@
+import {
+  normalizeLarkAtMentions
+} from "./roy-agent-core-m880qz3y.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-6awgfh3x.js";
+
+// src/env/error-reply.ts
+init_logger();
+import { spawn } from "node:child_process";
+var logger = createLogger("env:error-reply");
+var UPSTREAM_RETRY_PATTERNS = [
+  /failed after \d+ attempts/i,
+  /endpoint is unavailable/i,
+  /upstream request failed/i,
+  /rate.?limit/i,
+  /\b429\b/,
+  /\b50[0234]\b/,
+  /service (is )?(temporarily )?unavailable/i,
+  /\beconn(reset|refused|aborted)\b/i,
+  /socket hang up/i,
+  /fetch failed/i,
+  /network error/i,
+  /overloaded/i
+];
+var TIMEOUT_PATTERNS = [
+  /timeout/i,
+  /timed out/i,
+  /deadline exceeded/i,
+  /etimedout/i,
+  /aborted due to timeout/i
+];
+var TRANSPORT_ABORT_PATTERNS = [
+  /requestabortederror/i,
+  /econnaborted/i,
+  /connection (was )?(aborted|reset|closed)/i,
+  /premature close/i
+];
+var ABORT_PATTERNS = [
+  /\babort(?:ed|ing)?\b/i,
+  /operation was cancelled/i,
+  /operation was canceled/i,
+  /sigint/i,
+  /\binterrupted\b/i,
+  /exiting due to (signal|shutdown)/i
+];
+var CONTEXT_PATTERNS = [
+  /context threshold/i,
+  /context (window|length|limit)/i,
+  /token limit/i,
+  /maximum context/i,
+  /ctrieve\b/,
+  /CTX_001/
+];
+var ASK_USER_PATTERNS = [/__ASK_USER_ERROR__/];
+function collectErrorText(error, depth = 0) {
+  const parts = [];
+  const push = (v) => {
+    if (typeof v === "string" && v.length > 0)
+      parts.push(v);
+  };
+  if (error === null || error === undefined)
+    return "";
+  if (typeof error === "string") {
+    push(error);
+    return parts.join(`
+`);
+  }
+  if (typeof error !== "object") {
+    push(String(error));
+    return parts.join(`
+`);
+  }
+  const e = error;
+  push(e.name);
+  push(e.message);
+  for (const key of ["statusCode", "status", "code"]) {
+    const v = e[key];
+    if (typeof v === "number" || typeof v === "string")
+      push(String(v));
+  }
+  if (depth < 3) {
+    const nested = collectErrorText(e.lastError, depth + 1);
+    if (nested)
+      parts.push(nested);
+    if (Array.isArray(e.errors)) {
+      for (const inner of e.errors.slice(-3)) {
+        const s = collectErrorText(inner, depth + 1);
+        if (s)
+          parts.push(s);
+      }
+    }
+    const cause = collectErrorText(e.cause, depth + 1);
+    if (cause)
+      parts.push(cause);
+  }
+  return parts.join(`
+`);
+}
+function truncate(text, max) {
+  if (text.length <= max)
+    return text;
+  return text.slice(0, max) + "…";
+}
+var FAILURE_RULES = [
+  {
+    id: "ask_user",
+    kind: "ask_user",
+    names: ["AskUserError"],
+    patterns: ASK_USER_PATTERNS,
+    notify: false,
+    title: "等待用户回答",
+    reason: "agent 正在等待用户回答，不是失败。",
+    retryable: false
+  },
+  {
+    id: "context_overflow",
+    kind: "context_overflow",
+    names: ["ContextError"],
+    patterns: CONTEXT_PATTERNS,
+    notify: true,
+    title: "上下文超出限制",
+    reason: "这次对话的上下文超出模型窗口，自动压缩也未能恢复。建议新开一个会话继续，或先让我压缩当前会话。",
+    retryable: false
+  },
+  {
+    id: "timeout",
+    kind: "timeout",
+    names: ["TimeoutError"],
+    patterns: TIMEOUT_PATTERNS,
+    notify: true,
+    title: "执行超时",
+    reason: "本次执行等待响应超时（上游长时间未返回或网络卡住）。建议稍后重试，或把任务拆小一些。",
+    retryable: true
+  },
+  {
+    id: "upstream_retry",
+    kind: "upstream_retry",
+    names: ["AI_RetryError", "RetryError", "APICallError", "AI_APICallError"],
+    patterns: UPSTREAM_RETRY_PATTERNS,
+    notify: true,
+    title: "模型服务暂时不可用（重试已用尽）",
+    reason: "调用模型时上游持续返回错误（如 429 限流 / 503 不可用），自动重试多次后仍未成功。" + "这不是你的操作问题，也不是仓库代码的问题 —— 稍后重发一次即可。",
+    retryable: true
+  },
+  {
+    id: "upstream_aborted",
+    kind: "upstream_aborted",
+    names: ["RequestAbortedError"],
+    patterns: TRANSPORT_ABORT_PATTERNS,
+    unless: TIMEOUT_PATTERNS,
+    notify: true,
+    title: "与模型服务的连接中断",
+    reason: "请求在传输过程中被中断（连接被重置 / 代理提前关闭），不是你的操作问题。稍后重发一次即可。",
+    retryable: true
+  },
+  {
+    id: "aborted",
+    kind: "aborted",
+    names: ["AbortError", "AbortSignal"],
+    patterns: ABORT_PATTERNS,
+    unless: [...TIMEOUT_PATTERNS, ...TRANSPORT_ABORT_PATTERNS],
+    notify: true,
+    title: "执行被中断",
+    reason: "本次执行在完成前被中断（可能你手动取消了，或进程收到了停止信号）。你可以直接让我重新执行。",
+    retryable: true
+  }
+];
+var UNKNOWN_RULE = {
+  id: "unknown",
+  kind: "unknown",
+  notify: true,
+  title: "执行异常失败",
+  reason: "本次执行遇到了未预期的异常，已中止。你可以重试；如果持续失败，请把这条消息里的技术细节发我。",
+  retryable: true
+};
+function ruleMatches(rule, name, text) {
+  const lowered = name.toLowerCase();
+  const nameHit = rule.names?.some((n) => n.toLowerCase() === lowered) ?? false;
+  const patternHit = rule.patterns?.some((p) => p.test(text)) ?? false;
+  if (!nameHit && !patternHit)
+    return false;
+  if (rule.unless?.some((p) => p.test(text)))
+    return false;
+  return true;
+}
+function getFailureRuleIds() {
+  return [...FAILURE_RULES.map((r) => r.id), UNKNOWN_RULE.id];
+}
+function classifyReactFailure(error) {
+  const text = collectErrorText(error);
+  const name = error && typeof error === "object" ? String(error.name ?? "") : "";
+  const technical = text ? truncate(text.replace(/\s*\n\s*/g, " | "), 400) : undefined;
+  const rule = FAILURE_RULES.find((r) => ruleMatches(r, name, text)) ?? UNKNOWN_RULE;
+  return {
+    kind: rule.kind,
+    ruleId: rule.id,
+    title: rule.title,
+    reason: rule.reason,
+    retryable: rule.retryable,
+    notify: rule.notify,
+    technical
+  };
+}
+var MAX_QUERY_PREVIEW = 200;
+function buildFailureReplyMarkdown(info, opts) {
+  const lines = [];
+  lines.push(`❌ **${info.title}**`);
+  lines.push("");
+  lines.push(info.reason);
+  const query = opts?.query?.trim();
+  if (query) {
+    lines.push("");
+    lines.push(`> 原始请求：${truncate(query.replace(/\s+/g, " "), MAX_QUERY_PREVIEW)}`);
+  }
+  if (info.retryable) {
+    lines.push("");
+    lines.push("**你可以：** 直接再发一次（重发即可，无需额外操作）。");
+  } else {
+    lines.push("");
+    lines.push("**你可以：** 新开一个会话，或先让我压缩当前会话。");
+  }
+  const technical = info.technical;
+  if (technical) {
+    lines.push("");
+    lines.push(`> 技术细节：${truncate(technical, 300)}`);
+  }
+  return lines.join(`
+`);
+}
+function extractReplyChannelFromEvent(envEvent) {
+  if (!envEvent || typeof envEvent !== "object")
+    return;
+  const e = envEvent;
+  const candidates = [
+    e.metadata?.replyChannel,
+    e.payload?.replyChannel
+  ];
+  for (const c of candidates) {
+    if (c && typeof c === "object") {
+      const ch = c;
+      if (ch.chatId || ch.messageId)
+        return ch;
+    }
+  }
+  return;
+}
+function isUsableChannel(ch) {
+  if (!ch)
+    return false;
+  if (!ch.chatId && !ch.messageId)
+    return false;
+  if (ch.type && !ch.type.toLowerCase().includes("lark"))
+    return false;
+  return true;
+}
+var repliedTriggers = new Map;
+var CHAT_DEDUP_WINDOW_MS = 5 * 60000;
+var MAX_DEDUP_ENTRIES = 1000;
+function makeDedupKey(channel, info, explicit, now = Date.now()) {
+  if (explicit)
+    return explicit;
+  if (channel.messageId)
+    return `msg:${channel.messageId}`;
+  if (channel.chatId) {
+    const bucket = Math.floor(now / CHAT_DEDUP_WINDOW_MS);
+    return `chat:${channel.chatId}:${info.kind}:${bucket}`;
+  }
+  return "unknown";
+}
+function isDuplicate(key, now = Date.now()) {
+  const at = repliedTriggers.get(key);
+  if (at === undefined)
+    return false;
+  if (key.startsWith("chat:") && now - at >= CHAT_DEDUP_WINDOW_MS) {
+    repliedTriggers.delete(key);
+    return false;
+  }
+  return true;
+}
+function rememberTrigger(key, now = Date.now()) {
+  if (repliedTriggers.size >= MAX_DEDUP_ENTRIES) {
+    const oldest = repliedTriggers.keys().next().value;
+    if (oldest !== undefined)
+      repliedTriggers.delete(oldest);
+  }
+  repliedTriggers.set(key, now);
+}
+function __resetFailureReplyDedupForTest() {
+  repliedTriggers.clear();
+}
+var DEFAULT_REPLY_TIMEOUT_MS = 5000;
+function spawnLarkReply(options) {
+  return new Promise((resolve, reject) => {
+    const { chatId, messageId, content, profile } = options;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_REPLY_TIMEOUT_MS;
+    let settled = false;
+    let timer;
+    const finish = (err) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      if (err)
+        reject(err);
+      else
+        resolve();
+    };
+    const normalizedContent = normalizeLarkAtMentions(content);
+    let args;
+    if (messageId) {
+      args = [
+        "im",
+        "+messages-reply",
+        "--message-id",
+        messageId,
+        "--markdown",
+        normalizedContent,
+        "--as",
+        "bot"
+      ];
+    } else if (chatId) {
+      args = [
+        "im",
+        "+messages-send",
+        "--chat-id",
+        chatId,
+        "--markdown",
+        normalizedContent,
+        "--as",
+        "bot"
+      ];
+    } else {
+      finish(new Error("No target specified for failure reply"));
+      return;
+    }
+    if (profile) {
+      args.unshift("--profile", profile);
+    }
+    let proc;
+    try {
+      proc = spawn("lark-cli", args, {
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (err) {
+      finish(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    timer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {}
+      finish(new Error(`lark-cli timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timer.unref?.();
+    let stderr = "";
+    proc.stdout?.on("data", () => {});
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0)
+        finish();
+      else
+        finish(new Error(`lark-cli exited with code ${code}: ${stderr}`));
+    });
+    proc.on("error", (err) => finish(err));
+  });
+}
+async function notifyReactFailure(options) {
+  const info = classifyReactFailure(options.error);
+  if (!info.notify) {
+    logger.debug(`[#4418] 命中规则 ${info.ruleId}（非失败），不发失败说明` + (options.sessionId ? ` (session=${options.sessionId})` : ""));
+    return { sent: false, kind: info.kind, info, skipped: "not_a_failure" };
+  }
+  const channel = (isUsableChannel(options.replyChannel) ? options.replyChannel : undefined) ?? extractReplyChannelFromEvent(options.envEvent);
+  if (!isUsableChannel(channel)) {
+    const hasTrigger = Boolean(options.envEvent);
+    const noChannelMsg = `[#4418] React 中断（${info.kind}/${info.ruleId}）无法定位 replyChannel，` + `飞书端收不到失败说明` + (hasTrigger ? " —— triggerEvent 存在但缺少 metadata.replyChannel" : "（本地执行，无 triggerEvent）") + (options.sessionId ? ` (session=${options.sessionId})` : "");
+    if (hasTrigger)
+      logger.warn(noChannelMsg);
+    else
+      logger.debug(noChannelMsg);
+    return { sent: false, kind: info.kind, info, skipped: "no_channel" };
+  }
+  const dedupKey = makeDedupKey(channel, info, options.dedupKey);
+  if (isDuplicate(dedupKey)) {
+    logger.info(`[#4418] React 中断（${info.kind}）已回复过 ${dedupKey}，跳过`);
+    return { sent: false, kind: info.kind, info, skipped: "duplicate" };
+  }
+  rememberTrigger(dedupKey);
+  const content = buildFailureReplyMarkdown(info, { query: options.query });
+  try {
+    await spawnLarkReply({
+      chatId: channel.chatId,
+      messageId: channel.messageId,
+      content,
+      profile: channel.profile,
+      timeoutMs: options.replyTimeoutMs
+    });
+    logger.info(`[#4418] React 中断（${info.kind}/${info.ruleId}）已回飞书 ` + `(${channel.messageId ?? channel.chatId})`);
+    return { sent: true, kind: info.kind, info };
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    repliedTriggers.delete(dedupKey);
+    logger.warn(`[#4418] React 中断（${info.kind}/${info.ruleId}）回飞书失败（已忽略）: ${errorMsg}`);
+    return { sent: false, kind: info.kind, info, error: errorMsg };
+  }
+}
+
+export { getFailureRuleIds, classifyReactFailure, buildFailureReplyMarkdown, __resetFailureReplyDedupForTest, notifyReactFailure };