@agent-wechat/agent-wechat 1.0.0-beta.11 → 1.0.0-beta.12

package/dist/index.js

@@ -114,13 +114,26 @@ import { delimiter, dirname, isAbsolute, join, toNamespacedPath } from "node:pat
 import { createConnection } from "node:net";
 
 // ../shared/dist/native.generated.js
-var NATIVE_MAX_SOURCE_BYTES = 26214383;
+var NATIVE_MAX_SOURCE_BYTES = 536870912;
+var NATIVE_MAX_ORDINARY_SOURCE_BYTES = 26214383;
+var NATIVE_MAX_VIDEO_SOURCE_BYTES = 52428800;
 
 // ../shared/dist/native-client.js
 function isNativeTombstone(value) {
   const item = value;
   return item?.deleted === true && typeof item.id === "string" && typeof item.version === "string";
 }
+function validateNativeRecallMetadata(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Invalid native recall metadata");
+  const recall = value;
+  if (recall.replacementText != null && (typeof recall.replacementText !== "string" || !recall.replacementText || recall.replacementText.length > 16384 || new TextEncoder().encode(recall.replacementText).length > 16384 || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\ufffe\uffff]/.test(recall.replacementText)))
+    throw new Error("Invalid native recall metadata");
+}
+function validateMessageRecall(message) {
+  if (message.recall != null)
+    validateNativeRecallMetadata(message.recall);
+}
 function listQuery(input) {
   const options = typeof input === "string" ? { cursor: input } : input;
   if (!options)
@@ -169,6 +182,7 @@ var NativeWeChatClient = class {
   token;
   fetchImpl;
   timeoutMs;
+  mediaTimeoutMs;
   streamIdleTimeoutMs;
   constructor(options) {
     this.baseUrl = validateNativeBaseUrl(options.baseUrl);
@@ -180,16 +194,19 @@ var NativeWeChatClient = class {
     this.token = options.token;
     this.fetchImpl = options.fetch ?? fetch;
     this.timeoutMs = options.timeoutMs ?? 3e4;
+    this.mediaTimeoutMs = options.mediaTimeoutMs ?? 60 * 6e4;
+    if (!Number.isInteger(this.mediaTimeoutMs) || this.mediaTimeoutMs < 1 || this.mediaTimeoutMs > 60 * 6e4)
+      throw new Error("Invalid native media timeout");
     this.streamIdleTimeoutMs = options.streamIdleTimeoutMs ?? 45e3;
     if (!Number.isInteger(this.streamIdleTimeoutMs) || this.streamIdleTimeoutMs < 1 || this.streamIdleTimeoutMs > 3e5)
       throw new Error("Invalid native stream idle timeout");
   }
-  async response(path, init = {}, stream = false) {
+  async response(path, init = {}, stream = false, timeoutMs = this.timeoutMs) {
     const headers = new Headers(init.headers);
     headers.set("Authorization", `Bearer ${this.token}`);
     if (init.body != null && !(init.body instanceof FormData))
       headers.set("Content-Type", "application/json");
-    const timeout = stream ? void 0 : AbortSignal.timeout(this.timeoutMs);
+    const timeout = stream ? void 0 : AbortSignal.timeout(timeoutMs);
     const signal = init.signal && timeout ? AbortSignal.any([init.signal, timeout]) : init.signal ?? timeout;
     const response = await this.fetchImpl(new URL(path, this.baseUrl), { ...init, headers, redirect: "error", signal });
     if (!response.ok) {
@@ -344,11 +361,51 @@ var NativeWeChatClient = class {
   contact(accountId, username) {
     return this.request(`v1/accounts/${id(accountId)}/contacts/${id(username)}`);
   }
-  group(accountId, roomId) {
-    return this.request(`v1/accounts/${id(accountId)}/groups/${id(roomId)}`);
+  group(accountId, roomId, signal) {
+    return this.request(`v1/accounts/${id(accountId)}/groups/${id(roomId)}`, { signal });
+  }
+  groupMembers(accountId, roomId, options, signal) {
+    return this.request(`v1/accounts/${id(accountId)}/groups/${id(roomId)}/members${listQuery(options)}`, { signal });
+  }
+  groupMember(accountId, roomId, username, signal) {
+    return this.request(`v1/accounts/${id(accountId)}/groups/${id(roomId)}/members/${id(username)}`, { signal });
+  }
+  async groupMutation(accountId, path, method, body, key, action, target, signal) {
+    if (typeof key !== "string" || !key || key.length > 200 || /[\u0000-\u001f\u007f]/.test(key))
+      throw new Error("A stable group idempotency key is required");
+    const operation = await this.request(`v1/accounts/${id(accountId)}/${path}`, { method, body: JSON.stringify(body), headers: { "Idempotency-Key": key }, signal });
+    const result = operation?.result;
+    if (!operation || operation.accountId !== accountId || operation.kind !== "group_mutation" || typeof operation.id !== "string" || !operation.id || !result || result.action !== action || result.targetId !== target)
+      throw new Error("Native group operation identity is invalid");
+    return operation;
+  }
+  /** A repeated key returns the same operation. Uncertain mutations must be inspected, never repeated with a new key. */
+  createGroup(accountId, input, key, signal) {
+    return this.groupMutation(accountId, "groups", "POST", input, key, "create", null, signal);
+  }
+  renameGroup(accountId, groupId, name3, key, signal) {
+    return this.groupMutation(accountId, `groups/${id(groupId)}`, "PATCH", { name: name3 }, key, "rename", groupId, signal);
+  }
+  leaveGroup(accountId, groupId, key, signal) {
+    return this.groupMutation(accountId, `groups/${id(groupId)}/leave`, "POST", {}, key, "leave", groupId, signal);
+  }
+  addGroupMembers(accountId, groupId, members, key, signal) {
+    return this.groupMutation(accountId, `groups/${id(groupId)}/members`, "POST", { members }, key, "add_members", groupId, signal);
+  }
+  removeGroupMembers(accountId, groupId, members, key, signal) {
+    return this.groupMutation(accountId, `groups/${id(groupId)}/members`, "DELETE", { members }, key, "remove_members", groupId, signal);
+  }
+  setMyGroupName(accountId, groupId, displayName, key, signal) {
+    return this.groupMutation(accountId, `groups/${id(groupId)}/my-name`, "PUT", { displayName }, key, "my_name", groupId, signal);
+  }
+  clearGroupAnnouncement(accountId, groupId, key, signal) {
+    return this.groupMutation(accountId, `groups/${id(groupId)}/announcement`, "DELETE", {}, key, "clear_announcement", groupId, signal);
   }
-  groupMembers(accountId, roomId, options) {
-    return this.request(`v1/accounts/${id(accountId)}/groups/${id(roomId)}/members${listQuery(options)}`);
+  setThreadMuted(accountId, threadId2, muted, key, signal) {
+    return this.groupMutation(accountId, `threads/${id(threadId2)}/notifications`, "PUT", { muted }, key, "mute", threadId2, signal);
+  }
+  groupMutationByKey(accountId, key, signal) {
+    return this.request(`v1/accounts/${id(accountId)}/group-mutations/by-idempotency-key?${new URLSearchParams({ key })}`, { signal });
   }
   refreshAvatar(accountId, username) {
     return this.request(`v1/accounts/${id(accountId)}/avatars/${id(username)}/refresh`, { method: "POST", body: "{}" });
@@ -384,6 +441,7 @@ var NativeWeChatClient = class {
         continue;
       if (typeof msg.id !== "string" || msg.accountId !== accountId || msg.threadId !== threadId2 || msg.serverId != null && (typeof msg.serverId !== "string" || !/^\d+$/.test(msg.serverId)))
         throw new Error("Invalid native message identity");
+      validateMessageRecall(msg);
     }
     return result;
   }
@@ -391,13 +449,16 @@ var NativeWeChatClient = class {
     const message = await this.request(`v1/accounts/${id(accountId)}/messages/${id(messageId)}`);
     if (message.id !== messageId || message.accountId !== accountId || message.serverId != null && (typeof message.serverId !== "string" || !/^\d+$/.test(message.serverId)))
       throw new Error("Invalid native message identity");
+    validateMessageRecall(message);
     return message;
   }
   /** Resolve only the stored original in this message's own conversation. */
   async quotedMessage(accountId, messageId) {
     const quote = await this.request(`v1/accounts/${id(accountId)}/messages/${id(messageId)}/quote`);
-    if (quote.accountId !== accountId || quote.messageId !== messageId || typeof quote.threadId !== "string" || !["resolved", "embedded", "missing", "invalid", "unsupported", "ambiguous"].includes(quote.state) || (quote.state === "resolved" ? !quote.message || quote.message.accountId !== accountId || quote.message.threadId !== quote.threadId || quote.message.id === messageId : quote.message != null))
+    if (quote.accountId !== accountId || quote.messageId !== messageId || typeof quote.threadId !== "string" || !["resolved", "embedded", "missing", "invalid", "unsupported", "ambiguous", "recalled"].includes(quote.state) || (quote.state === "resolved" ? !quote.message || quote.message.accountId !== accountId || quote.message.threadId !== quote.threadId || quote.message.id === messageId : quote.message != null))
       throw new Error("Invalid native quote identity");
+    if (quote.message)
+      validateMessageRecall(quote.message);
     return quote;
   }
   /** Account-wide local search, with the daemon's query-bound opaque cursor. */
@@ -408,13 +469,20 @@ var NativeWeChatClient = class {
         continue;
       if (typeof message.id !== "string" || message.accountId !== accountId || typeof message.threadId !== "string" || !message.threadId || message.serverId != null && (typeof message.serverId !== "string" || !/^\d+$/.test(message.serverId)))
         throw new Error("Invalid native archive message identity");
+      validateMessageRecall(message);
     }
     return result;
   }
-  sendText(accountId, threadId2, text3, idempotencyKey) {
+  /** Quote a locally stored text, image, voice, video, link, file or quoted reply in the same chat.
+   * Live acceptance and recipient rendering remain unverified; other source kinds are rejected.
+   */
+  sendText(accountId, threadId2, text3, idempotencyKey, quote) {
     if (!idempotencyKey || /[\r\n]/.test(idempotencyKey))
       throw new Error("An idempotency key is required");
-    return this.request(`v1/accounts/${id(accountId)}/sends`, { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify({ threadId: threadId2, text: text3 }) });
+    if (quote !== void 0 && (!quote || typeof quote !== "object" || Array.isArray(quote) || Object.keys(quote).some((key) => key !== "messageId" && key !== "serverId") || typeof quote.messageId !== "string" || !quote.messageId || quote.messageId.length > 8192 || typeof quote.serverId !== "string" || !/^[1-9]\d{0,19}$/.test(quote.serverId) || BigInt(quote.serverId) > 18446744073709551615n))
+      throw new Error("Invalid quote message identity");
+    const input = quote === void 0 ? { threadId: threadId2, text: text3 } : { kind: "text", threadId: threadId2, text: text3, quote };
+    return this.request(`v1/accounts/${id(accountId)}/sends`, { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify(input) });
   }
   send(accountId, sendId, signal) {
     return this.request(`v1/accounts/${id(accountId)}/sends/${id(sendId)}`, { signal });
@@ -432,12 +500,16 @@ var NativeWeChatClient = class {
   cancelSend(accountId, sendId) {
     return this.request(`v1/accounts/${id(accountId)}/sends/${id(sendId)}/cancel`, { method: "POST", body: "{}" });
   }
-  async upload(accountId, bytes, name2, contentType = "application/octet-stream", signal) {
-    if (!bytes.length || bytes.length > NATIVE_MAX_SOURCE_BYTES || !name2 || name2.length > 255 || /[\r\n/\\]/.test(name2))
+  /** A disk-backed Blob avoids holding the source in memory before staging. */
+  async upload(accountId, bytes, name3, contentType = "application/octet-stream", signal) {
+    const size = bytes instanceof Blob ? bytes.size : bytes.byteLength;
+    if (!size || size > NATIVE_MAX_SOURCE_BYTES || !name3 || name3.length > 255 || /[\r\n/\\]/.test(name3))
       throw new Error("Invalid bounded media upload");
+    const part = bytes instanceof Blob ? bytes.slice(0, bytes.size, contentType) : new Blob([bytes.buffer instanceof ArrayBuffer ? new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength) : new Uint8Array(bytes)], { type: contentType });
     const form = new FormData();
-    form.set("file", new Blob([new Uint8Array(bytes).buffer], { type: contentType }), name2);
-    return this.request(`v1/accounts/${id(accountId)}/uploads`, { method: "POST", body: form, signal });
+    form.set("file", part, name3);
+    const response = await this.response(`v1/accounts/${id(accountId)}/uploads`, { method: "POST", body: form, signal }, false, this.mediaTimeoutMs);
+    return JSON.parse(new TextDecoder().decode(await this.readBounded(response)));
   }
   sendMedia(accountId, input, key) {
     if (!key || /[\r\n]/.test(key))
@@ -459,26 +531,94 @@ var NativeWeChatClient = class {
   cancelJob(accountId, jobId) {
     return this.request(`v1/accounts/${id(accountId)}/jobs/${id(jobId)}/cancel`, { method: "POST", body: "{}" });
   }
-  retryJob(accountId, jobId) {
-    return this.request(`v1/accounts/${id(accountId)}/jobs/${id(jobId)}/retry`, { method: "POST", body: "{}" });
+  retryJob(accountId, jobId, options = {}) {
+    if (!options || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some((key) => key !== "reuseCompletedUpload"))
+      throw new Error("Invalid media retry options");
+    const reuse = options.reuseCompletedUpload;
+    if (reuse !== void 0 && typeof reuse !== "boolean")
+      throw new Error("Invalid media retry options");
+    return this.request(`v1/accounts/${id(accountId)}/jobs/${id(jobId)}/${reuse === true ? "retry-completed-upload" : "retry"}`, { method: "POST", body: JSON.stringify(reuse === void 0 ? {} : { reuseCompletedUpload: reuse }) });
   }
   repairMediaWriteback(accountId, limit = 25) {
     if (!Number.isInteger(limit) || limit < 1 || limit > 100)
       throw new Error("Invalid media writeback limit");
     return this.request(`v1/accounts/${id(accountId)}/media-writeback/repair`, { method: "POST", body: JSON.stringify({ limit }) });
   }
-  async mediaContent(accountId, assetId, options = {}) {
+  /** Consume the bounded stream once, or cancel it; this never starts a CDN transfer. */
+  async mediaContentStream(accountId, assetId, options = {}) {
     const max = options.maxBytes ?? 128 * 1024 * 1024;
-    if (!Number.isInteger(max) || max < 1 || max > 128 * 1024 * 1024 || options.range && !/^bytes=(?:\d+-\d*|-\d+)$/.test(options.range) || options.representation != null && !["original", "preview"].includes(options.representation))
+    if (!Number.isInteger(max) || max < 1 || max > Math.max(128 * 1024 * 1024, NATIVE_MAX_SOURCE_BYTES) || options.range && !/^bytes=(?:\d+-\d*|-\d+)$/.test(options.range) || options.representation != null && !["original", "preview"].includes(options.representation))
       throw new Error("Invalid bounded content request");
     const query = options.representation === "preview" ? "?representation=preview" : "";
-    const response = await this.response(`v1/accounts/${id(accountId)}/media/${id(assetId)}/content${query}`, { signal: options.signal, headers: options.range ? { Range: options.range } : {} });
+    const cancellation = new AbortController();
+    const response = await this.response(`v1/accounts/${id(accountId)}/media/${id(assetId)}/content${query}`, { signal: options.signal ? AbortSignal.any([options.signal, cancellation.signal]) : cancellation.signal, headers: options.range ? { Range: options.range } : {} }, false, this.mediaTimeoutMs);
     const length = response.headers.get("content-length");
     if (length && (!/^\d+$/.test(length) || Number(length) > max)) {
       await response.body?.cancel();
       throw new Error("Native media response exceeds its bound");
     }
-    return { bytes: await this.readBounded(response, max), contentType: response.headers.get("content-type") ?? "application/octet-stream", etag: response.headers.get("etag"), contentRange: response.headers.get("content-range"), sourceSha256: response.headers.get("x-source-sha256"), status: response.status };
+    if (!response.body && length && Number(length) > 0)
+      throw new Error("Native media response length mismatch");
+    let activeReader;
+    const iterate = async function* () {
+      cancellation.signal.throwIfAborted();
+      options.signal?.throwIfAborted();
+      const reader = response.body?.getReader();
+      if (!reader)
+        return;
+      activeReader = reader;
+      let size = 0;
+      try {
+        while (true) {
+          cancellation.signal.throwIfAborted();
+          options.signal?.throwIfAborted();
+          const { value, done } = await reader.read();
+          cancellation.signal.throwIfAborted();
+          options.signal?.throwIfAborted();
+          if (done)
+            break;
+          size += value.byteLength;
+          if (size > max)
+            throw new Error("Native media response exceeds its bound");
+          yield value;
+        }
+        if (length && size !== Number(length))
+          throw new Error("Native media response length mismatch");
+      } finally {
+        await reader.cancel().catch(() => {
+        });
+        reader.releaseLock();
+        activeReader = void 0;
+      }
+    };
+    let claimed = false;
+    const stream = { [Symbol.asyncIterator]() {
+      if (claimed)
+        throw new Error("Native media stream was already consumed");
+      claimed = true;
+      return iterate();
+    } };
+    return { stream, cancel: async () => {
+      cancellation.abort();
+      await (activeReader ? activeReader.cancel() : response.body?.cancel())?.catch(() => {
+      });
+    }, contentType: response.headers.get("content-type") ?? "application/octet-stream", etag: response.headers.get("etag"), contentRange: response.headers.get("content-range"), sourceSha256: response.headers.get("x-source-sha256"), status: response.status };
+  }
+  async mediaContent(accountId, assetId, options = {}) {
+    const { stream, cancel: _cancel, ...metadata } = await this.mediaContentStream(accountId, assetId, options);
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of stream) {
+      chunks.push(chunk);
+      size += chunk.byteLength;
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return { ...metadata, bytes };
   }
   markRead(accountId, threadId2, expectedVersion) {
     if (typeof expectedVersion !== "string" || !expectedVersion || expectedVersion.length > 128)
@@ -488,7 +628,12 @@ var NativeWeChatClient = class {
   events(accountId, after = "0", limit = 100) {
     if (!Number.isInteger(limit) || limit < 1 || limit > 200)
       throw new Error("Invalid event page limit");
-    return this.request(`v1/accounts/${id(accountId)}/events?after=${decimal(after)}&limit=${limit}`);
+    return this.request(`v1/accounts/${id(accountId)}/events?after=${decimal(after)}&limit=${limit}`).then((page) => {
+      for (const event of page.items)
+        if (event.kind === "message.recalled")
+          validateNativeRecallMetadata(event.data);
+      return page;
+    });
   }
   ack(accountId, consumerId, cursor) {
     return this.request(`v1/accounts/${id(accountId)}/consumers/${id(consumerId)}/ack`, { method: "POST", body: JSON.stringify({ cursor: decimal(cursor) }) });
@@ -552,6 +697,8 @@ var NativeWeChatClient = class {
               const event = payload;
               if (!event || typeof event.kind !== "string" || !event.data || typeof event.data !== "object")
                 throw new Error("Invalid native event");
+              if (event.kind === "message.recalled")
+                validateNativeRecallMetadata(event.data);
               event.cursor = decimal(event.cursor ?? eventCursor);
               yield event;
             }
@@ -598,7 +745,7 @@ function requireNativeIdentity(value) {
   }
 }
 function nativeChildEnvironment(token, environment = process.env) {
-  return Object.fromEntries(["PATH", "HOME", "USERPROFILE", "APPDATA", "LOCALAPPDATA", "SystemRoot", "WINDIR", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "TMPDIR", "TMP", "TEMP", "LANG", "LC_ALL", "TZ", "SSL_CERT_FILE", "SSL_CERT_DIR"].filter((name2) => environment[name2] !== void 0 && environment[name2] !== token).map((name2) => [name2, environment[name2]]));
+  return Object.fromEntries(["PATH", "HOME", "USERPROFILE", "APPDATA", "LOCALAPPDATA", "SystemRoot", "WINDIR", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "TMPDIR", "TMP", "TEMP", "LANG", "LC_ALL", "TZ", "SSL_CERT_FILE", "SSL_CERT_DIR"].filter((name3) => environment[name3] !== void 0 && environment[name3] !== token).map((name3) => [name3, environment[name3]]));
 }
 function nativeHostTarget(platform = process.platform, arch = process.arch) {
   const cpu = arch === "arm64" ? "aarch64" : "x86_64";
@@ -1034,15 +1181,21 @@ function resolveWeChatIngress(params) {
   });
 }
 
+// src/outbound-options.ts
+import { createHash as createHash6 } from "node:crypto";
+
 // src/outbound-media.ts
 import { createHash as createHash5 } from "node:crypto";
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/native-media.ts
 import { createHash as createHash4, randomUUID } from "node:crypto";
-import { open } from "node:fs/promises";
-import { basename, extname } from "node:path";
+import { openAsBlob } from "node:fs";
+import { mkdtemp, open, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, extname, join as join2 } from "node:path";
 import { getImageMetadata, resizeToJpeg, IMAGE_REDUCE_QUALITY_STEPS } from "openclaw/plugin-sdk/media-runtime";
+import { saveMediaStream } from "openclaw/plugin-sdk/media-store";
 
 // src/attachment-store.ts
 import { createHash as createHash3 } from "node:crypto";
@@ -1062,6 +1215,12 @@ async function saveManagedAttachment(params) {
   }
   const buffer = Buffer.from(params.data, "base64");
   if (buffer.byteLength !== size) throw new Error("Attachment decoding length mismatch");
+  return saveManagedAttachmentBytes({ ...params, bytes: buffer });
+}
+async function saveManagedAttachmentBytes(params) {
+  const size = params.bytes.byteLength;
+  if (size > params.maxBytes) throw new AttachmentTooLargeError(`Attachment exceeds configured ${params.maxBytes} byte limit`);
+  const buffer = Buffer.from(params.bytes.buffer, params.bytes.byteOffset, size);
   const sha256 = createHash3("sha256").update(buffer).digest("hex");
   const saved = await params.saveMediaBuffer(
     buffer,
@@ -1072,31 +1231,59 @@ async function saveManagedAttachment(params) {
   );
   return { path: saved.path, size, sha256, filename: params.filename };
 }
+async function saveVerifiedManagedAttachmentStream(params) {
+  if (!Number.isSafeInteger(params.expectedBytes) || params.expectedBytes < 1 || params.expectedBytes > params.maxBytes || !/^[a-f0-9]{64}$/.test(params.expectedSha256)) throw new Error("Native attachment integrity metadata is invalid");
+  let size = 0, finished = false;
+  const digest2 = createHash3("sha256");
+  const stream = (async function* () {
+    for await (const chunk of params.stream) {
+      params.assertCurrent();
+      size += chunk.byteLength;
+      if (size > params.maxBytes || size > params.expectedBytes) throw new AttachmentTooLargeError("Native attachment stream exceeds its bound");
+      digest2.update(chunk);
+      yield chunk;
+    }
+    params.assertCurrent();
+    if (size !== params.expectedBytes || digest2.digest("hex") !== params.expectedSha256) throw new Error("Native attachment integrity did not verify");
+    finished = true;
+  })();
+  const saved = await params.saveMediaStream(
+    stream,
+    params.mime,
+    "inbound",
+    params.maxBytes,
+    params.filename,
+    void 0,
+    { assertCommitAllowed: params.assertCurrent, durable: true }
+  );
+  if (!finished || saved.size != null && saved.size !== size) throw new Error("Native attachment stream was not fully saved");
+  return { path: saved.path, size, sha256: params.expectedSha256, filename: params.filename };
+}
 
 // src/media-delivery.ts
 function appendReference(body, reference) {
   return body ? `${body}
 ${reference}` : reference;
 }
-function safeDisplayName(name2) {
-  return name2.replace(/[\r\n\0]/g, " ").trim() || "attachment";
+function safeDisplayName(name3) {
+  return name3.replace(/[\r\n\0]/g, " ").trim() || "attachment";
 }
 function renderAttachmentBody(originalBody, attachment, exposeNonVisualPath = true) {
   if (!attachment) return originalBody;
-  const name2 = safeDisplayName(attachment.filename);
+  const name3 = safeDisplayName(attachment.filename);
   if (attachment.status !== "ready" || !attachment.path) {
     const label = attachment.kind === "file" ? "File" : attachment.kind === "image" ? "Image" : attachment.kind === "audio" ? "Voice message" : "Video";
     if (attachment.status === "pending") {
-      return appendReference(originalBody, `[${label} pending: ${name2}]`);
+      return appendReference(originalBody, `[${label} pending: ${name3}]`);
     }
     if (attachment.status === "expired") {
-      return appendReference(originalBody, `[${label} expired: ${name2}; no cached copy available. Ask the sender to resend.]`);
+      return appendReference(originalBody, `[${label} expired: ${name3}; no cached copy available. Ask the sender to resend.]`);
     }
-    return appendReference(originalBody, `[${label} unavailable: ${name2} (${attachment.status})]`);
+    return appendReference(originalBody, `[${label} unavailable: ${name3} (${attachment.status})]`);
   }
   if (attachment.kind === "file") {
-    const prefix = originalBody.trim() === name2 ? "" : originalBody;
-    return appendReference(prefix, `[File: ${name2}]
+    const prefix = originalBody.trim() === name3 ? "" : originalBody;
+    return appendReference(prefix, `[File: ${name3}]
 [Local file: <${attachment.path}>]`);
   }
   if (exposeNonVisualPath) {
@@ -1164,15 +1351,33 @@ async function submitNativeText(client, accountId, threadId2, text3, key, option
 
 // src/native-recall-state.ts
 function nativeRecallInfo(message) {
+  if (message.recall) validateNativeRecallMetadata(message.recall);
   return message.recall;
 }
 function nativeRecallIdentity(threadId2, serverId) {
   return JSON.stringify([threadId2, serverId]);
 }
 function validateNativeRecall(value) {
+  validateNativeRecallMetadata(value);
   if (!value || typeof value.threadId !== "string" || !value.threadId || value.threadId.length > 4096 || typeof value.serverId !== "string" || !/^[1-9]\d{0,19}$/.test(value.serverId) || BigInt(value.serverId) > 18446744073709551615n || typeof value.observedAt !== "string" || value.observedAt.length > 128 || !Number.isFinite(Date.parse(value.observedAt)) || value.recalledAt !== void 0 && (typeof value.recalledAt !== "string" || value.recalledAt.length > 128 || !Number.isFinite(Date.parse(value.recalledAt))) || value.messageId !== void 0 && (typeof value.messageId !== "string" || !value.messageId || value.messageId.length > 4096)) throw Error("Invalid native recall observation; cursor retained");
 }
+function mergeNativeRecall(prior, next) {
+  validateNativeRecall(prior);
+  validateNativeRecall(next);
+  if (prior.threadId !== next.threadId || prior.serverId !== next.serverId) throw Error("Conflicting native recall identity; cursor retained");
+  return {
+    threadId: prior.threadId,
+    serverId: prior.serverId,
+    observedAt: prior.observedAt,
+    ...prior.messageId ?? next.messageId ? { messageId: prior.messageId ?? next.messageId } : {},
+    ...prior.recalledAt ?? next.recalledAt ? { recalledAt: prior.recalledAt ?? next.recalledAt } : {},
+    ...(prior.replacementText ?? next.replacementText) != null ? { replacementText: prior.replacementText ?? next.replacementText } : {}
+  };
+}
 function recalledNativeMessage(message, recall) {
+  validateNativeRecall(recall);
+  const previous = nativeRecallInfo(message);
+  const replacementText = previous?.replacementText ?? recall.replacementText;
   return {
     ...message,
     type: 1e4,
@@ -1180,8 +1385,14 @@ function recalledNativeMessage(message, recall) {
     quote: void 0,
     link: void 0,
     media: [],
+    senderId: message.senderId || null,
+    direction: message.senderId ? message.direction : null,
     mentions: { state: "unknown", userIds: [], self: null, all: null, source: null },
-    recall: { observedAt: recall.observedAt, ...recall.recalledAt ? { recalledAt: recall.recalledAt } : {} }
+    recall: {
+      observedAt: previous?.observedAt ?? recall.observedAt,
+      ...previous?.recalledAt ?? recall.recalledAt ? { recalledAt: previous?.recalledAt ?? recall.recalledAt } : {},
+      ...replacementText != null ? { replacementText } : {}
+    }
   };
 }
 
@@ -1192,6 +1403,26 @@ function kind(type) {
 var terminalJobs = /* @__PURE__ */ new Set(["accepted", "completed", "succeeded", "available", "failed", "partial", "cancelled", "expired", "needs_review"]);
 var successfulSendJobs = /* @__PURE__ */ new Set(["accepted", "completed", "succeeded"]);
 var terminalIdentityErrors = /* @__PURE__ */ new Set(["media_identity_unavailable", "media_source_changed"]);
+var NativeMediaJobInspectionError = class extends Error {
+  code = "native_media_job_inspection_required";
+  retryable = false;
+  jobId;
+  accountId;
+  threadId;
+  idempotencyKey;
+  state;
+  reason;
+  constructor(job, accountId, threadId2, key, reason) {
+    super(`Native media job ${job.id} requires inspection (${job.state}); retain the original job and idempotency key and do not automatically resend`);
+    this.name = "NativeMediaJobInspectionError";
+    this.jobId = job.id;
+    this.accountId = accountId;
+    this.threadId = threadId2;
+    this.idempotencyKey = key;
+    this.state = job.state;
+    this.reason = reason;
+  }
+};
 function mediaSendResult(job) {
   return job.result && typeof job.result === "object" && !Array.isArray(job.result) ? job.result : {};
 }
@@ -1227,6 +1458,9 @@ async function waitNativeMediaSendReceipts(client, accountId, threadId2, initial
   return job;
 }
 async function waitNativeMediaJob(client, accountId, initial, timeoutMs = 65e3, signal, assertCurrent) {
+  return waitNativeMediaStatus(initial, timeoutMs, signal, assertCurrent, (job, pollSignal) => client.job(accountId, job.id, pollSignal));
+}
+async function waitNativeMediaStatus(initial, timeoutMs, signal, assertCurrent, readStatus) {
   const deadline = Date.now() + timeoutMs;
   let job = initial;
   let delay = 250;
@@ -1238,11 +1472,27 @@ async function waitNativeMediaJob(client, accountId, initial, timeoutMs = 65e3,
     if (remaining <= 0) break;
     signal?.throwIfAborted();
     assertCurrent?.();
-    job = await client.job(accountId, job.id, signal ? AbortSignal.any([signal, AbortSignal.timeout(remaining)]) : AbortSignal.timeout(remaining));
+    const next = await readStatus(job, signal ? AbortSignal.any([signal, AbortSignal.timeout(remaining)]) : AbortSignal.timeout(remaining));
+    if (!next) break;
+    job = next;
     delay = Math.min(delay * 2, 1e3);
   }
   return job;
 }
+async function incomingMediaJobStatus(client, accountId, jobId, assetId, signal, assertCurrent) {
+  let job;
+  assertCurrent();
+  try {
+    job = await client.job(accountId, jobId, signal);
+  } catch (error) {
+    assertCurrent();
+    if (error instanceof NativeApiError ? error.retryable && !terminalIdentityErrors.has(error.code) && error.code !== "message_recalled" : error instanceof TypeError || error instanceof DOMException && ["TimeoutError", "NetworkError", "AbortError"].includes(error.name)) return void 0;
+    throw error;
+  }
+  assertCurrent();
+  if (job.id !== jobId || job.accountId !== accountId || job.kind !== "download" || assetId != null && job.assetId != null && job.assetId !== assetId) throw Error("Native download job identity does not match its attachment");
+  return job;
+}
 function select(assets, type, quality = "best") {
   const preferred = type === 34 ? ["normal"] : type === 43 ? ["normal", "original"] : ["original", "standard", "thumbnail", "encoded"];
   const rank = (asset) => {
@@ -1419,7 +1669,10 @@ async function prepareNativeAttachmentInput(params) {
   if (message.type === 49 && message.appMessageType != null && message.appMessageType !== 6) return { body: `[Unsupported WeChat app message subtype ${message.appMessageType}]`, pending: false, retryable: false };
   if (!attachmentKind) return { body: message.type === 1 ? message.body ?? "" : `[Unsupported WeChat message type ${message.type}]`, pending: false };
   const accountId = account.native.accountId;
-  const maxBytes = Math.min(account.mediaMaxMb * 1024 * 1024, 128 * 1024 * 1024);
+  const maxBytes = Math.min(
+    account.mediaMaxMb * 1024 * 1024,
+    attachmentKind === "file" ? Math.max(NATIVE_MAX_SOURCE_BYTES, 128 * 1024 * 1024) : 128 * 1024 * 1024
+  );
   const scopedAssets = async () => {
     await authorize();
     const items = (await client.mediaAssets(accountId, message.id)).items;
@@ -1445,9 +1698,9 @@ async function prepareNativeAttachmentInput(params) {
   let transferError;
   if (!asset && initialCandidate?.jobId && initialCandidate.state !== "recalled") {
     await authorize();
-    job = await client.job(accountId, initialCandidate.jobId, params.signal);
+    job = await incomingMediaJobStatus(client, accountId, initialCandidate.jobId, initialCandidate.id, params.signal, guard);
     guard();
-    if (job.accountId !== accountId || job.kind !== "download" || job.assetId != null && job.assetId !== initialCandidate.id) throw Error("Native download job identity does not match its attachment");
+    if (!job) return { body: `[${attachmentKind} pending: retrieval is unavailable]`, pending: true, jobId: initialCandidate.jobId, retryable: true };
     assets = await scopedAssets();
     asset = select(assets, message.type, quality);
     if (!asset && transferCandidate()?.state === "recalled") return { body: "[Message recalled]", pending: false, retryable: false, reason: "message_recalled" };
@@ -1458,7 +1711,13 @@ async function prepareNativeAttachmentInput(params) {
     try {
       job = await client.transferMedia(accountId, { messageId: message.id, assetId: null, quality: transferQuality });
       guard();
-      job = await waitNativeMediaJob(client, accountId, job, params.waitMs ?? 2e4, params.signal, guard);
+      job = await waitNativeMediaStatus(
+        job,
+        params.waitMs ?? 2e4,
+        params.signal,
+        guard,
+        (known, pollSignal) => incomingMediaJobStatus(client, accountId, known.id, initialCandidate?.id, pollSignal, guard)
+      );
       guard();
     } catch (error) {
       guard();
@@ -1491,6 +1750,55 @@ async function prepareNativeAttachmentInput(params) {
     return { body: renderAttachmentBody("", attachment2), attachment: attachment2, pending: false };
   }
   await authorize();
+  if (attachmentKind === "file" && asset.byteLength != null && asset.byteLength > 128 * 1024 * 1024) {
+    const content2 = await client.mediaContentStream(accountId, asset.id, { maxBytes, signal: params.signal });
+    const mime2 = content2.contentType.split(";", 1)[0].trim().toLowerCase();
+    if (!/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/.test(mime2)) {
+      await content2.cancel();
+      throw Error("Native attachment MIME type is unsupported");
+    }
+    let saved2;
+    try {
+      saved2 = await saveVerifiedManagedAttachmentStream({
+        stream: content2.stream,
+        mime: mime2,
+        filename,
+        maxBytes,
+        expectedBytes: asset.byteLength,
+        expectedSha256: asset.sha256 ?? "",
+        assertCurrent: guard,
+        saveMediaStream: params.saveMediaStream ?? saveMediaStream
+      });
+    } finally {
+      await content2.cancel();
+    }
+    await authorize();
+    const attachment2 = { kind: "file", filename, status: "ready", path: saved2.path, mime: mime2 };
+    return {
+      body: renderAttachmentBody("", attachment2),
+      attachment: attachment2,
+      mediaMime: mime2,
+      pending: false,
+      jobId: job?.id,
+      retryable: false,
+      variant: asset.actualVariant ?? asset.variant,
+      suppliedAssets: [{
+        id: asset.id,
+        contextRole: "trigger",
+        role: "file_reference",
+        kind: "file",
+        path: saved2.path,
+        mime: mime2,
+        sha256: saved2.sha256,
+        byteLength: saved2.size,
+        runtimeMedia: false,
+        sourceSha256: saved2.sha256,
+        sourceByteLength: saved2.size,
+        sourceMime: mime2,
+        sourcePath: saved2.path
+      }]
+    };
+  }
   const content = await client.mediaContent(accountId, asset.id, { maxBytes, signal: params.signal });
   guard();
   const mime = content.contentType.split(";", 1)[0].trim().toLowerCase();
@@ -1498,7 +1806,7 @@ async function prepareNativeAttachmentInput(params) {
   const hash = createHash4("sha256").update(content.bytes).digest("hex");
   if (!asset.sha256 || hash !== asset.sha256 || asset.byteLength != null && asset.byteLength !== content.bytes.length) throw new Error("Native attachment integrity did not verify");
   await authorize();
-  const saved = await saveManagedAttachment({ data: Buffer.from(content.bytes).toString("base64"), mime, filename, maxBytes, saveMediaBuffer: core.channel.media.saveMediaBuffer });
+  const saved = await saveManagedAttachmentBytes({ bytes: content.bytes, mime, filename, maxBytes, saveMediaBuffer: core.channel.media.saveMediaBuffer });
   const actual = asset.actualVariant ?? asset.variant;
   const attachment = {
     kind: attachmentKind,
@@ -1570,78 +1878,114 @@ async function prepareNativeAttachmentInput(params) {
     pending: false
   };
 }
-async function sendNativeAttachment(client, account, threadId2, mediaUrl, audioAsVoice = false, key = randomUUID(), beforeSend) {
-  const max = Math.min(account.mediaMaxMb * 1024 * 1024, NATIVE_MAX_SOURCE_BYTES);
-  let bytes;
-  let filename;
-  let mime;
-  if (/^https?:/.test(mediaUrl)) {
-    const response = await fetch(mediaUrl, { redirect: "error", signal: AbortSignal.timeout(3e4) });
-    if (!response.ok) throw new Error(`Native outbound source unavailable (${response.status})`);
-    const length = response.headers.get("content-length");
-    if (length && (!/^\d+$/.test(length) || Number(length) > max)) {
-      await response.body?.cancel();
-      throw new Error("Native outbound source exceeds configured size");
-    }
-    const reader = response.body?.getReader();
-    if (!reader) throw new Error("Native outbound source has no bytes");
-    const chunks2 = [];
-    let size = 0;
-    try {
-      while (true) {
-        const { value, done } = await reader.read();
-        if (done) break;
-        size += value.length;
-        if (size > max) throw new Error("Native outbound source exceeds configured size");
-        chunks2.push(value);
+function validateNativeMediaSendOptions(options, audioAsVoice = false) {
+  if (options.forceDocument != null && typeof options.forceDocument !== "boolean") throw new Error("Invalid WeChat document option");
+  if (options.videoQuality != null && !["normal", "original"].includes(options.videoQuality)) throw new Error("Invalid WeChat video quality");
+  if (options.forceDocument && (audioAsVoice || options.videoQuality != null)) throw new Error("Document sending cannot also request voice or video quality");
+}
+function outboundMediaKind(mime, audioAsVoice, options) {
+  if (options.forceDocument) return "file";
+  if (audioAsVoice && !mime.startsWith("audio/")) throw new Error("Voice sending requires an explicit audio attachment");
+  const selected = audioAsVoice ? "voice" : mime.startsWith("image/") ? "image" : mime.startsWith("video/") ? "video" : "file";
+  if (options.videoQuality != null && selected !== "video") throw new Error("Video quality requires a video attachment");
+  return selected;
+}
+function outboundSourceLimit(account, selectedKind) {
+  return Math.min(account.mediaMaxMb * 1024 * 1024, selectedKind === "file" ? NATIVE_MAX_SOURCE_BYTES : selectedKind === "video" ? NATIVE_MAX_VIDEO_SOURCE_BYTES : NATIVE_MAX_ORDINARY_SOURCE_BYTES);
+}
+async function sendNativeAttachment(client, account, threadId2, mediaUrl, audioAsVoice = false, key = randomUUID(), beforeSend, options = {}) {
+  validateNativeMediaSendOptions(options, audioAsVoice);
+  await beforeSend?.();
+  let filename, mime, selectedKind, sourceBytes, source;
+  let temporary;
+  const accountId = account.native.accountId;
+  try {
+    let blob;
+    if (/^https?:/.test(mediaUrl)) {
+      const response = await fetch(mediaUrl, { redirect: "error", signal: AbortSignal.timeout(60 * 6e4) });
+      if (!response.ok) throw new Error(`Native outbound source unavailable (${response.status})`);
+      filename = basename(new URL(mediaUrl).pathname) || "attachment";
+      mime = response.headers.get("content-type")?.split(";")[0].trim().toLowerCase() ?? "application/octet-stream";
+      try {
+        selectedKind = outboundMediaKind(mime, audioAsVoice, options);
+      } catch (error) {
+        await response.body?.cancel();
+        throw error;
       }
-    } catch (error) {
-      await reader.cancel();
-      throw error;
-    } finally {
-      reader.releaseLock();
-    }
-    bytes = new Uint8Array(size);
-    let offset = 0;
-    for (const chunk of chunks2) {
-      bytes.set(chunk, offset);
-      offset += chunk.length;
-    }
-    filename = basename(new URL(mediaUrl).pathname) || "attachment";
-    mime = response.headers.get("content-type")?.split(";")[0] ?? "application/octet-stream";
-  } else {
-    const path = mediaUrl.startsWith("file:") ? new URL(mediaUrl) : mediaUrl;
-    const file = await open(path, "r");
-    try {
-      const stat = await file.stat();
-      if (!stat.isFile() || stat.size === 0 || stat.size > max) throw new Error("Native outbound source must be a bounded regular file");
-      const chunks2 = [];
-      let size = 0;
-      while (true) {
-        const chunk = Buffer.alloc(Math.min(65536, max + 1 - size));
-        const { bytesRead } = await file.read(chunk, 0, chunk.length, null);
-        if (!bytesRead) break;
-        size += bytesRead;
-        if (size > max) throw new Error("Native outbound source exceeds configured size");
-        chunks2.push(chunk.subarray(0, bytesRead));
+      const max = outboundSourceLimit(account, selectedKind);
+      const length = response.headers.get("content-length");
+      if (length && (!/^\d+$/.test(length) || Number(length) > max)) {
+        await response.body?.cancel();
+        throw new Error("Native outbound source exceeds configured size");
       }
-      bytes = Buffer.concat(chunks2, size);
-    } finally {
-      await file.close();
+      const reader = response.body?.getReader();
+      if (!reader) throw new Error("Native outbound source has no bytes");
+      let path, file, size = 0;
+      try {
+        temporary = await mkdtemp(join2(tmpdir(), "wechat-outbound-"));
+        path = join2(temporary, "source");
+        file = await open(path, "wx", 384);
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          size += value.byteLength;
+          if (size > max) throw new Error("Native outbound source exceeds configured size");
+          await file.writeFile(value);
+        }
+        if (!size || length && size !== Number(length)) throw new Error("Native outbound source length mismatch");
+      } finally {
+        await reader.cancel().catch(() => {
+        });
+        reader.releaseLock();
+        await file?.close();
+      }
+      blob = await openAsBlob(path, { type: mime });
+    } else {
+      const path = mediaUrl.startsWith("file:") ? new URL(mediaUrl) : mediaUrl;
+      filename = basename(path instanceof URL ? path.pathname : path);
+      const extension = extname(filename).toLowerCase();
+      mime = [".png", ".jpg", ".jpeg", ".gif", ".webp"].includes(extension) ? `image/${extension === ".jpg" ? "jpeg" : extension.slice(1)}` : extension === ".mp4" ? "video/mp4" : [".wav", ".mp3", ".ogg", ".m4a", ".flac", ".aac"].includes(extension) ? `audio/${extension.slice(1)}` : "application/octet-stream";
+      selectedKind = outboundMediaKind(mime, audioAsVoice, options);
+      const max = outboundSourceLimit(account, selectedKind), file = await open(path, "r");
+      let size;
+      try {
+        const stat = await file.stat();
+        if (!stat.isFile() || !stat.size || stat.size > max) throw new Error("Native outbound source must be a bounded regular file");
+        size = stat.size;
+      } finally {
+        await file.close();
+      }
+      blob = await openAsBlob(path, { type: mime });
+      if (blob.size !== size) throw new Error("Native outbound source changed before staging");
     }
-    filename = basename(path instanceof URL ? path.pathname : path);
-    const extension = extname(filename).toLowerCase();
-    mime = [".png", ".jpg", ".jpeg", ".gif", ".webp"].includes(extension) ? `image/${extension === ".jpg" ? "jpeg" : extension.slice(1)}` : extension === ".mp4" ? "video/mp4" : [".wav", ".mp3", ".ogg", ".m4a", ".flac", ".aac"].includes(extension) ? `audio/${extension.slice(1)}` : "application/octet-stream";
+    sourceBytes = blob.size;
+    if (sourceBytes > outboundSourceLimit(account, selectedKind)) throw new Error("Native outbound source exceeds selected media kind size");
+    await beforeSend?.();
+    source = await client.upload(accountId, blob, filename, mime);
+  } finally {
+    if (temporary) await rm(temporary, { recursive: true, force: true });
   }
-  if (audioAsVoice && !mime.startsWith("audio/")) throw new Error("Voice sending requires an explicit audio attachment");
-  await beforeSend?.();
-  const accountId = account.native.accountId;
-  const source = await client.upload(accountId, bytes, filename, mime);
-  const input = { threadId: threadId2, kind: audioAsVoice ? "voice" : mime.startsWith("image/") ? "image" : mime.startsWith("video/") ? "video" : "file", sourceId: source.id, standardSourceId: null, thumbnailSourceId: null, playSeconds: null, durationMs: null };
+  const input = {
+    threadId: threadId2,
+    kind: selectedKind,
+    sourceId: source.id,
+    standardSourceId: null,
+    thumbnailSourceId: null,
+    playSeconds: null,
+    durationMs: null,
+    ...selectedKind === "video" ? { videoQuality: options.videoQuality ?? "normal" } : {}
+  };
   await beforeSend?.();
-  let job = await waitNativeMediaJob(client, accountId, await client.sendMedia(accountId, input, key), audioAsVoice ? 25 * 6e4 : 65e3);
+  const waitMs = audioAsVoice ? 25 * 6e4 : selectedKind === "video" || selectedKind === "file" && sourceBytes > NATIVE_MAX_ORDINARY_SOURCE_BYTES ? 60 * 6e4 : 65e3;
+  const submitted = await client.sendMedia(accountId, input, key);
+  let job;
+  try {
+    job = await waitNativeMediaJob(client, accountId, submitted, waitMs);
+  } catch {
+    throw new NativeMediaJobInspectionError(submitted, accountId, threadId2, key, "status_unavailable");
+  }
   if (successfulSendJobs.has(job.state)) job = await waitNativeMediaSendReceipts(client, accountId, threadId2, job, audioAsVoice);
-  if (!successfulSendJobs.has(job.state)) throw new Error(`Native media job ${job.id} requires inspection (${job.state}); retain completed items and do not automatically resend`);
+  if (!successfulSendJobs.has(job.state)) throw new NativeMediaJobInspectionError(job, accountId, threadId2, key, "job_not_completed");
   const result = mediaSendResult(job);
   const chunks = Array.isArray(result.chunks) ? result.chunks.filter((chunk) => chunk && typeof chunk === "object") : [];
   const serverIds = audioAsVoice ? chunks.filter((chunk) => chunk.state === "accepted" && typeof chunk.serverMessageId === "string").map((chunk) => chunk.serverMessageId) : job.serverMessageId ? [job.serverMessageId] : void 0;
@@ -1649,13 +1993,16 @@ async function sendNativeAttachment(client, account, threadId2, mediaUrl, audioA
 }
 
 // src/outbound-media.ts
-async function sendWeChatMedia(cfg, to, text3, mediaUrl, audioAsVoice = false, idempotencyKey) {
+async function sendWeChatMedia(cfg, to, text3, mediaUrl, audioAsVoice = false, idempotencyKey, options = {}, beforeSend) {
+  validateNativeMediaSendOptions(options, audioAsVoice);
+  if (!mediaUrl && (options.forceDocument || options.videoQuality != null)) throw new Error("WeChat media options require an attachment");
   const account = resolveWeChatAccount(cfg);
   if (!account?.native) throw new Error("No native daemon configured");
   const { client } = await ensureNativeHost(account.native);
   const key = idempotencyKey ?? randomUUID2();
   if (!mediaUrl) {
     if (audioAsVoice) throw new Error("Voice sending requires an audio attachment");
+    await beforeSend?.();
     const send = await submitNativeText(client, account.native.accountId, to, text3, key);
     return nativeOutboundDelivery(
       client,
@@ -1665,26 +2012,116 @@ async function sendWeChatMedia(cfg, to, text3, mediaUrl, audioAsVoice = false, i
       { sendId: send.id, state: send.state, serverIds: send.serverId ? [send.serverId] : void 0 }
     );
   }
-  const result = await sendNativeAttachment(client, account, to, mediaUrl, audioAsVoice, key);
-  if (text3) await submitNativeText(client, account.native.accountId, to, text3, createHash5("sha256").update(`${key}\0caption`).digest("hex"));
+  const result = await sendNativeAttachment(client, account, to, mediaUrl, audioAsVoice, key, beforeSend, options);
+  if (text3) {
+    await beforeSend?.();
+    await submitNativeText(client, account.native.accountId, to, text3, createHash5("sha256").update(`${key}\0caption`).digest("hex"));
+  }
   return result;
 }
 
+// src/outbound-options.ts
+function nativePayloadMediaOptions(payload) {
+  const value = payload.channelData?.["agent-wechat"];
+  if (value == null) return {};
+  if (typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((key) => key !== "videoQuality") || !["normal", "original"].includes(value.videoQuality)) throw Error("Invalid WeChat media options");
+  return { videoQuality: value.videoQuality };
+}
+var wechatMediaActions = {
+  describeMessageTool: () => ({ actions: ["send"], schema: { actions: ["send"], visibility: "all-configured", properties: {
+    channelData: { type: "object", description: "WeChat per-send media options. Use agent-wechat.videoQuality for a single video attachment.", additionalProperties: true, properties: {
+      "agent-wechat": { type: "object", additionalProperties: false, required: ["videoQuality"], properties: {
+        videoQuality: { type: "string", enum: ["normal", "original"], description: "WeChat video mode: normal prepares playback; original also retains the unchanged source video. Cannot combine with forceDocument." }
+      } }
+    } }
+  } } }),
+  prepareSendPayload: ({ ctx, payload }) => {
+    const options = nativePayloadMediaOptions(payload);
+    if (options.videoQuality == null) return void 0;
+    validateNativeMediaSendOptions({ ...options, forceDocument: ctx.params.forceDocument ?? ctx.params.asDocument }, payload.audioAsVoice);
+    return payload;
+  }
+};
+var NativeMediaPayloadInspectionError = class extends Error {
+  retryable = false;
+  code = "native_media_payload_inspection_required";
+  deliveries;
+  pendingJob;
+  constructor(deliveries, pendingJob) {
+    super("WeChat attachment batch requires inspection; retain completed receipts and do not automatically resend");
+    this.name = "NativeMediaPayloadInspectionError";
+    this.deliveries = deliveries;
+    this.pendingJob = pendingJob;
+  }
+};
+function createWeChatMediaHandlers(send = sendWeChatMedia) {
+  const key = (ctx, index = 0) => ctx.deliveryQueueId ? createHash6("sha256").update(JSON.stringify(["wechat-media", ctx.deliveryQueueId, ctx.deliveryPartIndex ?? 0, index])).digest("hex") : void 0;
+  const guard = (ctx) => async () => {
+    ctx.signal?.throwIfAborted();
+    await ctx.onPlatformSendDispatch?.();
+    ctx.signal?.throwIfAborted();
+    ctx.assertDirectAdapterHandoff?.();
+  };
+  return {
+    sendMedia: async (ctx) => ({
+      channel: "agent-wechat",
+      ...await send(ctx.cfg, ctx.to, ctx.text, ctx.mediaUrl, ctx.audioAsVoice, key(ctx), { forceDocument: ctx.forceDocument }, guard(ctx))
+    }),
+    sendPayload: async (ctx) => {
+      const options = { ...nativePayloadMediaOptions(ctx.payload), forceDocument: ctx.forceDocument };
+      const audioAsVoice = ctx.payload.audioAsVoice ?? ctx.audioAsVoice;
+      validateNativeMediaSendOptions(options, audioAsVoice);
+      const urls = [...new Set([...ctx.payload.mediaUrls ?? [], ctx.payload.mediaUrl ?? ctx.mediaUrl].filter((url2) => typeof url2 === "string" && !!url2))];
+      if (urls.length > 16 || options.videoQuality != null && urls.length !== 1) throw Error("WeChat video quality requires one attachment per send");
+      const deliveries = [];
+      for (const [index, mediaUrl] of (urls.length ? urls : [void 0]).entries()) {
+        let delivered;
+        try {
+          delivered = await send(ctx.cfg, ctx.to, index === 0 ? ctx.payload.text ?? ctx.text : "", mediaUrl, audioAsVoice, key(ctx, index), options, guard(ctx));
+        } catch (error) {
+          if (!deliveries.length) throw error;
+          throw new NativeMediaPayloadInspectionError(deliveries, error instanceof NativeMediaJobInspectionError ? { jobId: error.jobId, accountId: error.accountId, threadId: error.threadId, idempotencyKey: error.idempotencyKey } : void 0);
+        }
+        deliveries.push(delivered);
+        if (urls.length > 1) {
+          try {
+            await ctx.onDeliveryResult?.({ channel: "agent-wechat", ...delivered });
+          } catch {
+            throw new NativeMediaPayloadInspectionError(deliveries);
+          }
+        }
+        if (delivered.meta.outcome === "unknown") break;
+      }
+      const first = deliveries[0];
+      return {
+        channel: "agent-wechat",
+        ...first,
+        ...deliveries.length > 1 ? { meta: {
+          ...first.meta,
+          parts: deliveries,
+          retryable: false,
+          ...deliveries.some((part) => part.meta.outcome === "unknown") ? { outcome: "unknown", receiptState: "needs_review" } : {}
+        } } : {}
+      };
+    }
+  };
+}
+
 // src/native-monitor.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 import { createChannelMessageReplyPipeline } from "openclaw/plugin-sdk/channel-outbound";
 import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
 
 // src/native-consumer-state.ts
-import { createHash as createHash6, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID3 } from "node:crypto";
 import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2 } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join3 } from "node:path";
 var NativeConsumerState = class {
   file;
   value;
   constructor(directory, serverId, accountId) {
     if (!isAbsolute2(directory) || !serverId || !accountId) throw new Error("Native consumer state requires absolute storage and bound server/account identities");
-    this.file = join2(directory, `${createHash6("sha256").update(`${serverId}\0${accountId}`).digest("hex")}.json`);
+    this.file = join3(directory, `${createHash7("sha256").update(`${serverId}\0${accountId}`).digest("hex")}.json`);
     this.value = { schemaVersion: 1, serverId, accountId, cursor: "0", items: {} };
     if (existsSync(this.file)) {
       const stat = lstatSync(this.file);
@@ -1693,6 +2130,7 @@ var NativeConsumerState = class {
       if (parsed.schemaVersion !== 1 || parsed.serverId !== serverId || parsed.accountId !== accountId || !/^\d+$/.test(parsed.cursor) || !parsed.items || typeof parsed.items !== "object") throw new Error("Native consumer identity or schema mismatch; state was preserved");
       for (const [id2, item] of Object.entries(parsed.items)) {
         if (item.message?.id !== id2 || item.message.accountId !== accountId || typeof item.message.threadId !== "string" || !["received", "dispatching", "handed_off", "completed", "ignored", "needs_review"].includes(item.state)) throw new Error("Invalid native custody record; state was preserved");
+        nativeRecallInfo(item.message);
         if (item.cursor != null && !/^\d+$/.test(item.cursor) || item.groupContext != null && typeof item.groupContext !== "boolean") throw new Error("Invalid native group context record; state was preserved");
         if (item.revision != null && (typeof item.revision !== "string" || !item.revision || item.revision.length > 64)) throw Error("Invalid native custody revision; state was preserved");
         item.revision ??= randomUUID3();
@@ -1822,13 +2260,8 @@ var NativeConsumerState = class {
     }
     const key = nativeRecallIdentity(recall.threadId, recall.serverId);
     this.value.recalls ??= {};
-    this.value.recalls[key] ??= {
-      threadId: recall.threadId,
-      serverId: recall.serverId,
-      observedAt: recall.observedAt,
-      ...recall.messageId ? { messageId: recall.messageId } : {},
-      ...recall.recalledAt ? { recalledAt: recall.recalledAt } : {}
-    };
+    const remembered = mergeNativeRecall(this.value.recalls[key] ?? recall, recall);
+    this.value.recalls[key] = remembered;
     const affected = /* @__PURE__ */ new Set();
     for (const item of this.items()) {
       if (item.message.threadId !== recall.threadId) continue;
@@ -1836,7 +2269,7 @@ var NativeConsumerState = class {
       const quote = item.message.quote?.serverId === recall.serverId;
       if (!target && !quote) continue;
       affected.add(item.message.id);
-      item.message = target ? recalledNativeMessage(item.message, recall) : { ...item.message, quote: void 0 };
+      item.message = target ? recalledNativeMessage(item.message, remembered) : { ...item.message, quote: void 0 };
       if (target) item.groupContext = false;
       item.readPending = false;
       if (["dispatching", "handed_off"].includes(item.state)) item.state = "needs_review";
@@ -1907,7 +2340,7 @@ var NativeConsumerState = class {
     });
     const revisions = items.map((item) => item.revision);
     if (new Set(items.map((item) => item.message.threadId)).size !== 1) throw new Error("Prepared input manifest crosses threads");
-    const manifestHash = createHash6("sha256").update(JSON.stringify({
+    const manifestHash = createHash7("sha256").update(JSON.stringify({
       accountId: this.value.accountId,
       messageIds: exact,
       dispatchManifests: items.map((item) => item.dispatchManifest ?? null)
@@ -1916,7 +2349,7 @@ var NativeConsumerState = class {
       const runId = typeof args[0] === "string" ? args[0] : args[0]?.runId;
       if (typeof runId !== "string" || !runId || runId.length > 256) throw new Error("Prepared run callback has no valid runId");
       this.mutate(() => {
-        const currentHash = createHash6("sha256").update(JSON.stringify({
+        const currentHash = createHash7("sha256").update(JSON.stringify({
           accountId: this.value.accountId,
           messageIds: exact,
           dispatchManifests: exact.map((id2) => this.value.items[id2]?.dispatchManifest ?? null)
@@ -1935,11 +2368,11 @@ var NativeConsumerState = class {
 };
 
 // src/native-prepared-boundary.ts
-import { createHash as createHash7, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID4 } from "node:crypto";
 import { basename as basename2, isAbsolute as isAbsolute3 } from "node:path";
 var pending = /* @__PURE__ */ new Map();
 var enabled = false;
-var digest = (value) => createHash7("sha256").update(value).digest("hex");
+var digest = (value) => createHash8("sha256").update(value).digest("hex");
 function prune() {
   for (const [id2, item] of pending) if (item.expires < Date.now()) pending.delete(id2);
 }
@@ -1950,7 +2383,7 @@ function nativeDispatchManifest(params) {
   const history = params.history ?? [];
   if (history.length > 200 || history.some((message) => message.accountId !== params.message.accountId || message.threadId !== params.message.threadId || message.id === params.message.id)) throw Error("Invalid native history manifest");
   const assets = Object.freeze((params.assets ?? []).map((asset) => {
-    if (typeof asset.id !== "string" || !asset.id || asset.id.length > 2048 || !/^[a-f0-9]{64}$/.test(asset.sha256) || !Number.isSafeInteger(asset.byteLength) || asset.byteLength < 1 || asset.byteLength > 128 * 1024 * 1024 || typeof asset.path !== "string" || !isAbsolute3(asset.path) || asset.path.length > 4096 || typeof asset.mime !== "string" || asset.mime.length > 128 || !/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/.test(asset.mime) || !["image", "audio", "video", "file"].includes(asset.kind) || !["model_image", "file_reference"].includes(asset.role) || asset.role === "model_image" && (asset.kind !== "image" || !asset.mime.startsWith("image/") || !asset.runtimeMedia) || !["trigger", "history"].includes(asset.contextRole) || asset.sourceMessageId != null && (typeof asset.sourceMessageId !== "string" || !asset.sourceMessageId || asset.sourceMessageId.length > 8192 || ![params.message, ...history].some((message) => message.id === asset.messageId && message.type === 49 && message.appMessageType === 57 && message.quote?.type === 3)) || asset.contextRole === "history" && !history.some((message) => message.id === asset.messageId)) throw Error("Invalid native supplied asset manifest");
+    if (typeof asset.id !== "string" || !asset.id || asset.id.length > 2048 || !/^[a-f0-9]{64}$/.test(asset.sha256) || !Number.isSafeInteger(asset.byteLength) || asset.byteLength < 1 || asset.byteLength > (asset.kind === "file" ? NATIVE_MAX_SOURCE_BYTES : 128 * 1024 * 1024) || typeof asset.path !== "string" || !isAbsolute3(asset.path) || asset.path.length > 4096 || typeof asset.mime !== "string" || asset.mime.length > 128 || !/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/.test(asset.mime) || !["image", "audio", "video", "file"].includes(asset.kind) || !["model_image", "file_reference"].includes(asset.role) || asset.role === "model_image" && (asset.kind !== "image" || !asset.mime.startsWith("image/") || !asset.runtimeMedia) || !["trigger", "history"].includes(asset.contextRole) || asset.sourceMessageId != null && (typeof asset.sourceMessageId !== "string" || !asset.sourceMessageId || asset.sourceMessageId.length > 8192 || ![params.message, ...history].some((message) => message.id === asset.messageId && message.type === 49 && message.appMessageType === 57 && message.quote?.type === 3)) || asset.contextRole === "history" && !history.some((message) => message.id === asset.messageId)) throw Error("Invalid native supplied asset manifest");
     return Object.freeze({ ...asset });
   }));
   const messageSid = nativeSourceMessageSid(params.message);
@@ -2463,12 +2896,12 @@ async function dispatchNativeMessageInput(params, revision) {
           if (urls.length > 16) throw new Error("Native reply media count exceeds its bound");
           if (payload.audioAsVoice && !urls.length) throw new Error("Native voice reply requires an audio attachment");
           for (const url2 of urls) {
-            const key = createHash8("sha256").update(`${dispatchManifest.messageSid}\0${delivery++}`).digest("hex");
+            const key = createHash9("sha256").update(`${dispatchManifest.messageSid}\0${delivery++}`).digest("hex");
             await sendNativeAttachment(client, account, message.threadId, url2, payload.audioAsVoice === true, key, beforeSend);
           }
           if (payload.text) {
             await beforeSend();
-            const key = createHash8("sha256").update(`${dispatchManifest.messageSid}\0${delivery++}`).digest("hex");
+            const key = createHash9("sha256").update(`${dispatchManifest.messageSid}\0${delivery++}`).digest("hex");
             await submitNativeText(client, account.native.accountId, message.threadId, payload.text, key);
           }
           if (urls.length || payload.text) params.onDelivered?.();
@@ -2724,6 +3157,7 @@ async function sendWeChatText(cfg, to, text3) {
   if (!account?.serverUrl) throw new Error("No native daemon configured");
   return sendNativeText(account, to, text3);
 }
+var mediaHandlers = createWeChatMediaHandlers();
 var wechatMessageAdapter = createChannelMessageAdapterFromOutbound({
   id: "agent-wechat",
   capabilities: {
@@ -2736,10 +3170,7 @@ var wechatMessageAdapter = createChannelMessageAdapterFromOutbound({
       channel: "agent-wechat",
       ...await sendWeChatText(cfg, to, text3)
     }),
-    sendMedia: async ({ cfg, to, text: text3, mediaUrl, audioAsVoice }) => ({
-      channel: "agent-wechat",
-      ...await sendWeChatMedia(cfg, to, text3, mediaUrl, audioAsVoice)
-    })
+    ...mediaHandlers
   }
 });
 var meta = {
@@ -2763,6 +3194,7 @@ var wechatPlugin = {
     tts: { voice: { synthesisTarget: "voice-note", transcodesAudio: true } }
   },
   reload: { configPrefixes: ["channels.agent-wechat"] },
+  actions: wechatMediaActions,
   configSchema: {
     uiHints: { "native.token": { sensitive: true } },
     schema: {
@@ -2884,10 +3316,7 @@ var wechatPlugin = {
       channel: "agent-wechat",
       ...await sendWeChatText(cfg, to, text3)
     }),
-    sendMedia: async ({ cfg, to, text: text3, mediaUrl, audioAsVoice }) => ({
-      channel: "agent-wechat",
-      ...await sendWeChatMedia(cfg, to, text3, mediaUrl, audioAsVoice)
-    })
+    ...mediaHandlers
   },
   message: wechatMessageAdapter,
   gateway: {
@@ -3054,7 +3483,7 @@ function createNativeFacade(config, dependencies = {}) {
       fail(res, 403, "facade_account_forbidden");
       return true;
     }
-    if (!["GET", "HEAD", "POST", "PATCH", "DELETE"].includes(req.method ?? "")) {
+    if (!["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE"].includes(req.method ?? "")) {
       fail(res, 405, "method_not_allowed");
       return true;
     }
@@ -3067,19 +3496,23 @@ function createNativeFacade(config, dependencies = {}) {
     try {
       const host2 = dependencies.endpoint ? void 0 : await ensureNativeHost(config);
       const headers = new Headers();
-      for (const name2 of ["content-type", "accept", "range", "if-none-match", "if-range", "last-event-id", "idempotency-key"]) {
-        const value = req.headers[name2];
-        if (typeof value === "string") headers.set(name2, value);
+      for (const name3 of ["content-type", "accept", "range", "if-none-match", "if-range", "last-event-id", "idempotency-key"]) {
+        const value = req.headers[name3];
+        if (typeof value === "string") headers.set(name3, value);
       }
+      const upload = pieces.length === 4 && pieces[3] === "uploads" && req.method === "POST";
+      const mediaContent = pieces.length === 6 && pieces[3] === "media" && pieces[5] === "content" && parsed.searchParams.get("representation") !== "preview";
+      const requestLimit = upload ? NATIVE_MAX_SOURCE_BYTES + 64 * 1024 : MAX_BODY;
+      const responseLimit = mediaContent ? Math.max(MAX_BODY, NATIVE_MAX_SOURCE_BYTES) : MAX_BODY;
       const length = req.headers["content-length"];
-      if (length && (!/^\d+$/.test(length) || Number(length) > MAX_BODY)) {
+      if (length && (!/^\d+$/.test(length) || Number(length) > requestLimit)) {
         fail(res, 413, "payload_too_large");
         return true;
       }
       let size = 0;
       const body = ["GET", "HEAD"].includes(req.method ?? "") ? void 0 : Readable.toWeb(req).pipeThrough(new NodeTransformStream({ transform(chunk, controller) {
         size += chunk.byteLength;
-        if (size > MAX_BODY) {
+        if (size > requestLimit) {
           tooLarge = true;
           throw new Error("payload_too_large");
         }
@@ -3092,10 +3525,16 @@ function createNativeFacade(config, dependencies = {}) {
         headers.set("Authorization", `Bearer ${dependencies.token}`);
         response = await (dependencies.fetch ?? fetch)(new URL(relative, dependencies.endpoint), init);
       }
+      const responseLength = response.headers.get("content-length");
+      if (responseLength && (!/^\d+$/.test(responseLength) || Number(responseLength) > responseLimit)) {
+        await response.body?.cancel();
+        fail(res, 502, "native_facade_unavailable");
+        return true;
+      }
       res.statusCode = response.status;
-      for (const name2 of ["content-type", "content-length", "content-range", "accept-ranges", "etag", "cache-control", "content-disposition", "x-content-type-options"]) {
-        const value = response.headers.get(name2);
-        if (value) res.setHeader(name2, value);
+      for (const name3 of ["content-type", "content-length", "content-range", "accept-ranges", "etag", "cache-control", "content-disposition", "x-content-type-options"]) {
+        const value = response.headers.get(name3);
+        if (value) res.setHeader(name3, value);
       }
       res.setHeader("x-content-type-options", "nosniff");
       const reader = response.body?.getReader();
@@ -3110,7 +3549,7 @@ function createNativeFacade(config, dependencies = {}) {
           const { value, done } = await reader.read();
           if (done) break;
           emitted += value.length;
-          if (!sse && emitted > MAX_BODY) throw new Error("upstream_response_too_large");
+          if (!sse && emitted > responseLimit) throw new Error("upstream_response_too_large");
           if (!res.write(value)) await drain(res, abort.signal);
         }
       } finally {
@@ -3154,8 +3593,8 @@ function object(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw Error("Expected tool arguments");
   return value;
 }
-function string(value, name2, max = 4096) {
-  if (typeof value !== "string" || !value.trim() || value.length > max || /[\u0000-\u001f\u007f]/.test(value)) throw Error(`Invalid ${name2}`);
+function string(value, name3, max = 4096) {
+  if (typeof value !== "string" || !value.trim() || value.length > max || /[\u0000-\u001f\u007f]/.test(value)) throw Error(`Invalid ${name3}`);
   return value.trim();
 }
 function threadId(value) {
@@ -3227,9 +3666,9 @@ function createLookupTools(context, dependencies, archive) {
     if (!currentThread) return [];
   }
   const selectedId = selected.native.accountId;
-  const tool = (name2, action, description, properties, required = []) => ({
-    name: name2,
-    label: name2.replaceAll("_", " "),
+  const tool = (name3, action, description, properties, required = []) => ({
+    name: name3,
+    label: name3.replaceAll("_", " "),
     description,
     // The pinned host's tool_call wrapper JSON-serializes image blocks. Its
     // public direct-only surface preserves actual image content for vision.
@@ -3530,7 +3969,7 @@ function registerNativeShareTools(api) {
 }
 
 // src/native-recall-tools.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 import { resolveStableChannelMessageIngress as resolveStableChannelMessageIngress4 } from "openclaw/plugin-sdk/channel-ingress-runtime";
 var names2 = ["wechat_recall"];
 function text2(value, label) {
@@ -3541,7 +3980,7 @@ function thread2(value) {
   return text2(text2(value, "conversation").replace(/^(?:agent-)?wechat:(?:group:)?/i, ""), "conversation");
 }
 function nativeRecallKey(accountId, threadId2, messageId, serverId) {
-  return `openclaw-recall-${createHash9("sha256").update(JSON.stringify([accountId, threadId2, messageId, serverId])).digest("hex")}`;
+  return `openclaw-recall-${createHash10("sha256").update(JSON.stringify([accountId, threadId2, messageId, serverId])).digest("hex")}`;
 }
 function createNativeRecallTools(context, dependencies = {}) {
   const currentConfig = () => context.getRuntimeConfig?.() ?? context.runtimeConfig ?? context.config;
@@ -3664,6 +4103,55 @@ function registerNativeRecallTools(api) {
   api.registerTool({ contextVersion: 2, create: (context) => createNativeRecallTools(context) }, { names: names2 });
 }
 
+// src/native-group-tool.ts
+var name2 = "wechat_group_info";
+function createNativeGroupTools(context, dependencies = {}) {
+  if (context.senderIsOwner !== true || typeof context.assertInvocationCurrent !== "function") return [];
+  const currentConfig = () => context.getRuntimeConfig?.() ?? context.runtimeConfig ?? context.config;
+  const selected = resolveWeChatAccount(currentConfig());
+  if (!selected?.enabled || !selected.native || context.agentAccountId && context.agentAccountId !== selected.accountId || context.deliveryContext?.channel === "agent-wechat" && context.deliveryContext.accountId && context.deliveryContext.accountId !== selected.accountId) return [];
+  const accountId = selected.native.accountId;
+  const configurationKey = nativeConfigurationKey(selected.native);
+  return [{
+    name: name2,
+    label: "WeChat Group Info",
+    description: "Read cached group information and one page of members for the configured WeChat account. Available only to the trusted OpenClaw owner. Does not create groups, invite people or change settings. Cached member absence does not prove non-membership.",
+    parameters: { type: "object", additionalProperties: false, properties: {
+      groupId: { type: "string", minLength: 10, maxLength: 256, description: "Exact ordinary group username ending in @chatroom." },
+      limit: { type: "integer", minimum: 1, maximum: 100 },
+      cursor: { type: "string", maxLength: 8192 },
+      username: { type: "string", minLength: 1, maxLength: 256, description: "Optionally inspect one exact member instead of listing a page." }
+    }, required: ["groupId"] },
+    execute: async (_callId, input, signal) => {
+      if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((k) => !["groupId", "limit", "cursor", "username"].includes(k))) throw Error("Invalid group info request");
+      const args = input;
+      const identity = (value) => typeof value === "string" && value.length > 0 && value.length <= 256 && !/[\s\u0000-\u001f\u007f]/u.test(value);
+      if (!identity(args.groupId) || !args.groupId.endsWith("@chatroom") || args.groupId.length <= 9 || args.limit != null && (!Number.isInteger(args.limit) || Number(args.limit) < 1 || Number(args.limit) > 100) || args.cursor != null && (typeof args.cursor !== "string" || args.cursor.length > 8192) || args.username != null && !identity(args.username) || args.username != null && (args.limit != null || args.cursor != null)) throw Error("Invalid group info selectors");
+      const guard = () => {
+        signal?.throwIfAborted();
+        if (context.senderIsOwner !== true) throw Error("OpenClaw owner authorization is required");
+        context.assertInvocationCurrent();
+        const account = resolveWeChatAccount(currentConfig());
+        if (!account?.enabled || !account.native || account.accountId !== selected.accountId || account.native.accountId !== accountId || nativeConfigurationKey(account.native) !== configurationKey) throw Error("WeChat account configuration changed; start a new turn");
+        return account.native;
+      };
+      const native = guard();
+      const { client } = await (dependencies.host ?? ensureNativeHost)(native);
+      guard();
+      const group = await client.group(accountId, args.groupId, signal);
+      guard();
+      if (group.id !== args.groupId || group.roomId !== args.groupId) throw Error("Group identity is invalid");
+      const members = typeof args.username === "string" ? await client.groupMember(accountId, args.groupId, args.username, signal) : await client.groupMembers(accountId, args.groupId, { limit: args.limit == null ? 50 : Number(args.limit), cursor: args.cursor }, signal);
+      guard();
+      const details = { accountId, group, members, source: "cached", membershipAbsence: "unconfirmed" };
+      return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+    }
+  }];
+}
+function registerNativeGroupTools(api) {
+  api.registerTool({ contextVersion: 2, create: (context) => createNativeGroupTools(context) }, { names: [name2] });
+}
+
 // index.ts
 var plugin = {
   id: "agent-wechat",
@@ -3677,6 +4165,7 @@ var plugin = {
     registerNativeHistoryTools(api);
     registerNativeShareTools(api);
     registerNativeRecallTools(api);
+    registerNativeGroupTools(api);
     const stopFacade = selected?.native ? registerNativeFacade(api, selected.native) : () => {
     };
     const stopPreparedBoundary = selected?.native?.readPolicy && selected.native.readPolicy !== "on_inbound" ? registerNativePreparedBoundary(api) : () => {