@qwen-code/qwen-code 0.21.6 → 0.21.7-nightly.20260808.4ec0371e6

package/chunks/{dist-DPPHJAVL.js → dist-BATY7GI4.js}

@@ -14,8 +14,9 @@ import {
   ChannelBase,
   ChannelProactiveDeliveryError,
   isChannelProactiveDeliveryError,
-  isTerminalTaskLifecycleType
-} from "./chunk-DIEFUBV6.js";
+  isTerminalTaskLifecycleType,
+  sanitizeSenderName
+} from "./chunk-DIWZNWZT.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-H6XPXXMH.js";
 import {
@@ -88998,6 +88999,7 @@ __name(downloadMedia, "downloadMedia");
 
 // packages/channels/feishu/dist/FeishuAdapter.js
 var DEDUP_TTL_MS = 5 * 60 * 1e3;
+var OBSERVED_LABEL_CACHE_LIMIT = 500;
 var CARD_UPDATE_INTERVAL_MS = 1500;
 var FEISHU_RUNNING_STATUS_LABEL = "\u8FD0\u884C\u4E2D...";
 var FEISHU_STOPPED_STATUS_LABEL = "\u5DF2\u505C\u6B62\u751F\u6210";
@@ -89047,6 +89049,15 @@ var FeishuChannel = class extends ChannelBase {
   botOpenId;
   tokenCache;
   tokenRefreshPromise;
+  // Core (non-silent) callers waiting on the shared token refresh, so a
+  // silent-initiated refresh still logs token errors for them.
+  tokenRefreshHasCoreWaiters = false;
+  observedUserNames = /* @__PURE__ */ new Map();
+  observedChatNames = /* @__PURE__ */ new Map();
+  observedUserLookups = /* @__PURE__ */ new Map();
+  observedChatLookups = /* @__PURE__ */ new Map();
+  observedContactWrites = /* @__PURE__ */ new Map();
+  hydratedObservedNames = false;
   collapsible;
   collapsibleThreshold;
   constructor(name, config, bridge, options) {
@@ -89385,10 +89396,12 @@ var FeishuChannel = class extends ChannelBase {
     text = text.replace(/^好的，<at[^>]*><\/at>\s*\n*/, "");
     return text.trim() || void 0;
   }
-  async getTenantAccessToken() {
+  async getTenantAccessToken(options) {
     if (this.tokenCache && Date.now() < this.tokenCache.expiresAt) {
       return this.tokenCache.token;
     }
+    if (!options?.silent)
+      this.tokenRefreshHasCoreWaiters = true;
     if (this.tokenRefreshPromise)
       return this.tokenRefreshPromise;
     this.tokenRefreshPromise = this.refreshToken();
@@ -89396,6 +89409,7 @@ var FeishuChannel = class extends ChannelBase {
       return await this.tokenRefreshPromise;
     } finally {
       this.tokenRefreshPromise = void 0;
+      this.tokenRefreshHasCoreWaiters = false;
     }
   }
   async refreshToken() {
@@ -89410,8 +89424,10 @@ var FeishuChannel = class extends ChannelBase {
         signal: AbortSignal.timeout(15e3)
       });
       if (!resp.ok) {
-        process.stderr.write(`[Feishu:${this.name}] getTenantAccessToken failed: HTTP ${resp.status}
+        if (this.tokenRefreshHasCoreWaiters) {
+          process.stderr.write(`[Feishu:${this.name}] getTenantAccessToken failed: HTTP ${resp.status}
 `);
+        }
         if (resp.status === 401)
           this.tokenCache = void 0;
         return void 0;
@@ -89424,11 +89440,172 @@ var FeishuChannel = class extends ChannelBase {
       };
       return this.tokenCache.token;
     } catch (err) {
-      process.stderr.write(`[Feishu:${this.name}] getTenantAccessToken error: ${err}
+      if (this.tokenRefreshHasCoreWaiters) {
+        process.stderr.write(`[Feishu:${this.name}] getTenantAccessToken error: ${err}
 `);
+      }
       return void 0;
     }
   }
+  hydrateObservedNames() {
+    if (this.hydratedObservedNames)
+      return;
+    this.hydratedObservedNames = true;
+    const graph = this.persistedObservedContacts();
+    if (!graph)
+      return;
+    const newestUser = /* @__PURE__ */ new Map();
+    const newestChat = /* @__PURE__ */ new Map();
+    const consider = /* @__PURE__ */ __name((best, id, label, at) => {
+      if (label === id)
+        return;
+      const current = best.get(id);
+      if (!current || at >= current.at)
+        best.set(id, { label, at });
+    }, "consider");
+    for (const user of graph.users) {
+      consider(newestUser, user.id, user.label, user.lastObservedAt);
+    }
+    for (const group of graph.groups) {
+      consider(newestChat, group.id, group.label, group.lastObservedAt);
+      for (const member of group.users) {
+        consider(newestUser, member.id, member.label, member.lastObservedAt);
+      }
+    }
+    for (const [id, entry] of newestUser) {
+      this.observedUserNames.set(id, entry.label);
+    }
+    for (const [id, entry] of newestChat) {
+      this.observedChatNames.set(id, entry.label);
+    }
+    this.capObservedCache(this.observedUserNames);
+    this.capObservedCache(this.observedChatNames);
+  }
+  /** Evicts the oldest-inserted entries once a runtime cache exceeds the cap. */
+  capObservedCache(cache) {
+    let evicted = false;
+    while (cache.size > OBSERVED_LABEL_CACHE_LIMIT) {
+      const oldest = cache.keys().next();
+      if (oldest.done)
+        break;
+      cache.delete(oldest.value);
+      evicted = true;
+    }
+    return evicted;
+  }
+  observedUserName(userId) {
+    const userIdType = userId.startsWith("ou_") ? "open_id" : userId.startsWith("on_") ? "union_id" : "user_id";
+    return this.observedNameLookup({
+      lookups: this.observedUserLookups,
+      names: this.observedUserNames,
+      id: userId,
+      request: /* @__PURE__ */ __name((token) => fetch(`${BASE_URL2}/contact/v3/users/basic_batch?user_id_type=${userIdType}`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ user_ids: [userId] }),
+        signal: AbortSignal.timeout(15e3)
+      }), "request"),
+      extractName: /* @__PURE__ */ __name((body) => {
+        const data = body;
+        return data.code === 0 ? data.data?.users?.[0]?.name : void 0;
+      }, "extractName")
+    });
+  }
+  observedChatName(chatId) {
+    return this.observedNameLookup({
+      lookups: this.observedChatLookups,
+      names: this.observedChatNames,
+      id: chatId,
+      request: /* @__PURE__ */ __name((token) => fetch(`${BASE_URL2}/im/v1/chats/${encodeURIComponent(chatId)}`, {
+        headers: { Authorization: `Bearer ${token}` },
+        signal: AbortSignal.timeout(15e3)
+      }), "request"),
+      extractName: /* @__PURE__ */ __name((body) => {
+        const data = body;
+        return data.code === 0 ? data.data?.name : void 0;
+      }, "extractName")
+    });
+  }
+  observedNameLookup(options) {
+    const cached = options.names.get(options.id);
+    if (cached)
+      return Promise.resolve(cached);
+    const existing = options.lookups.get(options.id);
+    if (existing)
+      return existing;
+    const lookup = (async () => {
+      try {
+        const token = await this.getTenantAccessToken({ silent: true });
+        if (!token) {
+          options.lookups.delete(options.id);
+          return void 0;
+        }
+        const response = await options.request(token);
+        if (!response.ok) {
+          if (response.status === 401) {
+            this.tokenCache = void 0;
+            options.lookups.delete(options.id);
+          }
+          return void 0;
+        }
+        const name = options.extractName(await response.json())?.trim();
+        if (!name)
+          return void 0;
+        const label = sanitizeSenderName(name);
+        if (label === "unknown")
+          return void 0;
+        options.names.set(options.id, label);
+        if (this.capObservedCache(options.names)) {
+          this.hydratedObservedNames = false;
+        }
+        return label;
+      } catch {
+        return void 0;
+      }
+    })();
+    options.lookups.set(options.id, lookup);
+    this.capObservedCache(options.lookups);
+    return lookup;
+  }
+  onObservedContact(envelope) {
+    this.observedContactWrites.set(this.observedContactKey(envelope), {
+      senderName: envelope.senderName,
+      chatName: envelope.chatName
+    });
+    this.capObservedCache(this.observedContactWrites);
+    void this.enrichObservedContact(envelope).catch(() => {
+    });
+  }
+  observedContactKey(envelope) {
+    return envelope.isGroup ? `${envelope.senderId}\0${envelope.chatId}\0${envelope.threadId ?? ""}` : envelope.senderId;
+  }
+  async enrichObservedContact(envelope) {
+    const [senderName, chatName] = await Promise.all([
+      this.observedUserName(envelope.senderId),
+      envelope.isGroup ? this.observedChatName(envelope.chatId) : Promise.resolve(void 0)
+    ]);
+    if (!senderName && !chatName)
+      return;
+    const key = this.observedContactKey(envelope);
+    const nextLabels = {
+      senderName: senderName ?? envelope.senderName,
+      chatName: chatName ?? envelope.chatName
+    };
+    const persistedLabels = this.observedContactWrites.get(key);
+    if (persistedLabels && persistedLabels.senderName === nextLabels.senderName && persistedLabels.chatName === nextLabels.chatName) {
+      return;
+    }
+    this.observedContactWrites.set(key, nextLabels);
+    this.capObservedCache(this.observedContactWrites);
+    await this.recordObservedContact({
+      ...envelope,
+      ...senderName ? { senderName } : {},
+      ...chatName ? { chatName } : {}
+    });
+  }
   async sendMessage(chatId, text) {
     await this.sendMessageInternal(chatId, text, false);
   }
@@ -90286,6 +90463,9 @@ ${contentPart}` : prefix : contentPart;
       const isGroup = msg.chat_type === "group";
       const chatId = msg.chat_id;
       const senderId = sender.sender_id?.open_id || sender.sender_id?.user_id || sender.sender_id?.union_id || "";
+      this.hydrateObservedNames();
+      const senderName = this.observedUserNames.get(senderId) || senderId;
+      const chatName = isGroup ? this.observedChatNames.get(chatId) : void 0;
       const content = this.extractContent(msg.message_type, msg.content);
       let isMentioned = false;
       let cleanText = content.text;
@@ -90315,8 +90495,9 @@ ${contentPart}` : prefix : contentPart;
       const envelope = {
         channelName: this.name,
         senderId,
-        senderName: senderId,
+        senderName,
         chatId,
+        ...chatName ? { chatName } : {},
         text: cleanText,
         messageId: msgId,
         threadId: msg.root_id || void 0,