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

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);
   }
-  groupMembers(accountId, roomId, options) {
-    return this.request(`v1/accounts/${id(accountId)}/groups/${id(roomId)}/members${listQuery(options)}`);
+  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);
+  }
+  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,15 +449,9 @@ 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))
-      throw new Error("Invalid native quote identity");
-    return quote;
-  }
   /** Account-wide local search, with the daemon's query-bound opaque cursor. */
   async searchMessages(accountId, options) {
     const result = await this.request(`v1/accounts/${id(accountId)}/messages${listQuery(options)}`);
@@ -408,13 +460,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 +491,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 +522,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 +619,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 +688,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 +736,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 +1172,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 +1206,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 +1222,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) {
@@ -1150,13 +1328,13 @@ async function nativeOutboundDelivery(client, accountId, threadId2, messageIds,
 async function submitNativeText(client, accountId, threadId2, text3, key, options = {}) {
   let intent = await client.sendText(accountId, threadId2, text3, key);
   const deadline = Date.now() + Math.max(1, Math.min(options.timeoutMs ?? 65e3, 65e3));
-  let delay = Math.max(1, Math.min(options.initialDelayMs ?? 250, 1e3));
+  let delay2 = Math.max(1, Math.min(options.initialDelayMs ?? 250, 1e3));
   while (["queued", "submitting"].includes(intent.state) && Date.now() < deadline) {
-    await new Promise((resolve) => setTimeout(resolve, Math.min(delay, deadline - Date.now())));
+    await new Promise((resolve) => setTimeout(resolve, Math.min(delay2, deadline - Date.now())));
     const remaining = deadline - Date.now();
     if (remaining <= 0) break;
     intent = await client.send(accountId, intent.id, AbortSignal.timeout(remaining));
-    delay = Math.min(delay * 2, 1e3);
+    delay2 = Math.min(delay2 * 2, 1e3);
   }
   if (!["accepted", "sent", "server_accepted"].includes(intent.state)) throw new Error(`Native send ${intent.id} requires inspection (${intent.state}); do not automatically resend`);
   return intent;
@@ -1164,15 +1342,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 +1376,42 @@ 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 } : {}
+    }
+  };
+}
+
+// src/native-quote.ts
+function renderEmbeddedQuote(message, permitted = true, imageBody) {
+  const comment = (message.body ?? "").slice(0, 16384);
+  const source = message.quote;
+  const unavailable = (state2) => ({
+    body: `${comment}${comment ? "\n\n" : ""}[Quoted message ${state2}]`,
+    image: false,
+    quote: { state: state2, type: source?.type, senderId: source?.senderId ?? void 0 }
+  });
+  if (!source) return unavailable("unavailable");
+  if (!permitted) return unavailable("not permitted");
+  const state = source.state ?? "missing";
+  if (state === "recalled") return unavailable("recalled");
+  if (!["embedded", "missing", "unsupported"].includes(state) || source.embeddedText != null && (typeof source.embeddedText !== "string" || source.embeddedText.length > 16384) || source.embeddedImage != null && typeof source.embeddedImage !== "boolean") return unavailable("invalid");
+  const label = source.type === 1 ? "text" : source.type === 3 ? "image" : source.type === 34 ? "voice" : source.type === 43 ? "video" : source.type === 49 && source.appMessageType === 5 ? "link" : source.type === 49 && source.appMessageType === 6 ? "file" : "message";
+  const image = state === "embedded" && source.type === 3 && source.embeddedImage === true;
+  if (state === "embedded" && !image && !source.embeddedText) return unavailable("invalid");
+  const content = state === "missing" ? "" : image ? imageBody ?? "[Image metadata embedded in quote; image not retrieved]" : source.embeddedText ?? "";
+  const status = state === "unsupported" ? `[${label} attachment unavailable from embedded quote]` : state === "missing" ? "[Embedded quote content unavailable]" : "";
+  return {
+    body: `${comment}${comment ? "\n\n" : ""}[Quoted ${label} from ${source.senderId ?? "unknown sender"}; embedded in reply]
+${[content, status].filter(Boolean).join("\n")}
+[/Quoted message]`,
+    image,
+    quote: { state, type: source.type, senderId: source.senderId ?? void 0 }
   };
 }
 
@@ -1192,6 +1422,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 : {};
 }
@@ -1207,11 +1457,11 @@ function mediaSendReceiptIds(job, audioAsVoice) {
 async function waitNativeMediaSendReceipts(client, accountId, threadId2, initial, audioAsVoice, timeoutMs = 1e4) {
   if (initial.accountId !== accountId || initial.threadId !== threadId2 || initial.kind !== "send") throw Error("Native media receipt job identity mismatch; inspect the submitted job and do not resend");
   const deadline = Date.now() + Math.max(0, Math.min(timeoutMs, 1e4));
-  let job = initial, delay = 100;
+  let job = initial, delay2 = 100;
   while (successfulSendJobs.has(job.state) && !mediaSendReceiptIds(job, audioAsVoice) && Date.now() < deadline) {
     const result = mediaSendResult(job);
     if (["unknown", "not_applicable"].includes(String(result.profileProjection)) || audioAsVoice && Array.isArray(result.chunks) && result.chunks.some((chunk) => !chunk || chunk.state !== "accepted")) break;
-    await new Promise((resolve) => setTimeout(resolve, Math.min(delay, Math.max(0, deadline - Date.now()))));
+    await new Promise((resolve) => setTimeout(resolve, Math.min(delay2, Math.max(0, deadline - Date.now()))));
     const remaining = deadline - Date.now();
     if (remaining <= 0) break;
     let next;
@@ -1222,27 +1472,46 @@ async function waitNativeMediaSendReceipts(client, accountId, threadId2, initial
     }
     if (next.id !== initial.id || next.accountId !== accountId || next.threadId !== threadId2 || next.kind !== "send" || next.sourceId !== initial.sourceId || initial.serverMessageId != null && next.serverMessageId !== initial.serverMessageId) break;
     job = next;
-    delay = Math.min(delay * 2, 1e3);
+    delay2 = Math.min(delay2 * 2, 1e3);
   }
   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;
+  let delay2 = 250;
   while (!terminalJobs.has(job.state) && Date.now() < deadline) {
     signal?.throwIfAborted();
     assertCurrent?.();
-    await new Promise((resolve) => setTimeout(resolve, Math.min(delay, Math.max(0, deadline - Date.now()))));
+    await new Promise((resolve) => setTimeout(resolve, Math.min(delay2, Math.max(0, deadline - Date.now()))));
     const remaining = deadline - Date.now();
     if (remaining <= 0) break;
     signal?.throwIfAborted();
     assertCurrent?.();
-    job = await client.job(accountId, job.id, signal ? AbortSignal.any([signal, AbortSignal.timeout(remaining)]) : AbortSignal.timeout(remaining));
-    delay = Math.min(delay * 2, 1e3);
+    const next = await readStatus(job, signal ? AbortSignal.any([signal, AbortSignal.timeout(remaining)]) : AbortSignal.timeout(remaining));
+    if (!next) break;
+    job = next;
+    delay2 = Math.min(delay2 * 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) => {
@@ -1301,83 +1570,37 @@ ${prepared.body}`,
   };
 }
 async function prepareNativeQuote(params) {
-  const { client, account, message } = params;
-  const guard = () => {
+  const { message } = params;
+  const guard2 = () => {
     params.signal?.throwIfAborted();
     params.assertCurrent?.();
   };
-  guard();
-  const comment = (message.body ?? "").slice(0, 16384);
-  const unavailable = (state) => ({ body: `${comment}${comment ? "\n\n" : ""}[Quoted message ${state}; original lookup is confined to this chat]`, pending: false, retryable: state === "unavailable", quote: { state } });
-  await params.beforeMediaAccess?.();
-  guard();
-  let resolution;
-  try {
-    resolution = await client.quotedMessage(account.native.accountId, message.id);
-  } catch (error) {
-    guard();
-    if (!(error instanceof NativeApiError)) throw error;
-    if (error.code === "message_recalled") return { ...unavailable("recalled"), retryable: false, reason: "message_recalled" };
-    return terminalIdentityErrors.has(error.code) ? { ...unavailable("unavailable"), retryable: false, reason: error.code } : unavailable("unavailable");
-  }
-  guard();
-  if (resolution.accountId !== message.accountId || resolution.messageId !== message.id || resolution.threadId !== message.threadId) throw Error("Native quote identity does not match its message");
-  if (resolution.state === "recalled" || resolution.message && nativeRecallInfo(resolution.message)) return { ...unavailable("recalled"), retryable: false, reason: "message_recalled" };
-  if (!message.quote) return unavailable("invalid");
-  if (resolution.state === "embedded") {
-    if (resolution.message != null || (message.quote.type === 1 ? typeof resolution.embeddedText !== "string" || resolution.embeddedText.length > 16384 : message.quote.type !== 3 || resolution.embeddedImage !== true)) throw Error("Invalid embedded quote resolution");
-    const author = { senderId: resolution.senderId ?? null, direction: null };
-    if (params.allowQuotedMessage && !await params.allowQuotedMessage(author)) return unavailable("not permitted");
-    guard();
-    const quote2 = { state: "embedded", senderId: resolution.senderId ?? void 0, type: message.quote.type };
-    const prefix2 = `${comment}${comment ? "\n\n" : ""}[Quoted ${message.quote.type === 3 ? "image" : "text"} from ${resolution.senderId ?? "unknown sender"}; embedded in quote, original not stored]
-`;
-    if (message.quote.type === 1) return { body: `${prefix2}${resolution.embeddedText}
-[/Quoted message]`, pending: false, quote: quote2 };
-    const beforeMediaAccess2 = async () => {
-      await params.beforeMediaAccess?.();
-      guard();
-      if (params.allowQuotedMessage && !await params.allowQuotedMessage(author)) throw Error("Quoted message is no longer permitted");
-      guard();
-    };
-    const prepared2 = await prepareNativeAttachment({ ...params, message: { ...message, type: 3, appMessageType: void 0, quote: void 0 }, beforeMediaAccess: beforeMediaAccess2 });
-    return {
-      ...prepared2,
-      body: `${prefix2}${prepared2.body}
-[/Quoted message]`,
-      pending: false,
-      quote: quote2,
-      ...prepared2.pending ? { attachment: { kind: "image", status: "pending", filename: "quoted-image" } } : {}
-    };
-  }
-  if (resolution.state !== "resolved") {
-    if (!["missing", "invalid", "unsupported", "ambiguous"].includes(resolution.state) || resolution.message != null) throw Error("Invalid native quote resolution");
-    return unavailable(resolution.state);
-  }
-  const original = resolution.message;
-  if (!original || original.accountId !== message.accountId || original.threadId !== message.threadId || original.id === message.id || original.serverId !== message.quote.serverId || original.type !== message.quote.type || ![1, 3].includes(original.type)) throw Error("Native quoted original crosses its message boundary");
-  if (params.allowQuotedMessage && !await params.allowQuotedMessage(original)) return unavailable("not permitted");
-  guard();
-  const quote = { state: "resolved", messageId: original.id, senderId: original.senderId ?? void 0, type: original.type };
-  const prefix = `${comment}${comment ? "\n\n" : ""}[Quoted ${original.type === 3 ? "image" : "text"} from ${original.senderId ?? "unknown sender"}; message ${original.id}]
-`;
-  if (original.type === 1) return { body: `${prefix}${(original.body ?? "").slice(0, 16384)}
-[/Quoted message]`, pending: false, quote };
+  guard2();
+  const author = { senderId: message.quote?.senderId ?? null, direction: message.quote?.direction ?? null };
+  const permitted = !message.quote || !params.allowQuotedMessage || await params.allowQuotedMessage(author);
+  guard2();
+  const rendered = renderEmbeddedQuote(message, permitted);
+  if (!rendered.image) return {
+    body: rendered.body,
+    quote: rendered.quote,
+    pending: false,
+    retryable: false,
+    ...rendered.quote.state === "recalled" ? { reason: "message_recalled" } : {}
+  };
   const beforeMediaAccess = async () => {
     await params.beforeMediaAccess?.();
-    guard();
-    if (params.allowQuotedMessage && !await params.allowQuotedMessage(original)) throw Error("Quoted message is no longer permitted");
-    guard();
+    guard2();
+    if (params.allowQuotedMessage && !await params.allowQuotedMessage(author)) throw Error("Quoted message is no longer permitted");
+    guard2();
   };
-  const prepared = await prepareNativeAttachment({ ...params, message: original, beforeMediaAccess });
+  const prepared = await prepareNativeAttachment({ ...params, message: { ...message, type: 3, appMessageType: void 0, quote: void 0, link: void 0 }, beforeMediaAccess });
+  if (prepared.reason === "message_recalled" || terminalIdentityErrors.has(prepared.reason ?? "")) return prepared;
   return {
     ...prepared,
-    body: `${prefix}${prepared.body}
-[/Quoted message]`,
+    body: renderEmbeddedQuote(message, true, prepared.body).body,
+    quote: rendered.quote,
     pending: false,
-    quote,
-    ...prepared.pending ? { attachment: { kind: "image", status: "pending", filename: "quoted-image" } } : {},
-    suppliedAssets: prepared.suppliedAssets?.map((asset) => ({ ...asset, sourceMessageId: original.id }))
+    ...prepared.pending ? { attachment: { kind: "image", status: "pending", filename: "quoted-image" } } : {}
   };
 }
 async function prepareNativeAttachment(params) {
@@ -1402,16 +1625,16 @@ async function prepareNativeAttachment(params) {
 async function prepareNativeAttachmentInput(params) {
   const { client, account, message, core } = params;
   const attachmentKind = kind(message.type);
-  const guard = () => {
+  const guard2 = () => {
     params.signal?.throwIfAborted();
     params.assertCurrent?.();
   };
-  guard();
+  guard2();
   if (nativeRecallInfo(message)) return { body: "[Message recalled]", pending: false, retryable: false, reason: "message_recalled" };
   const authorize = async () => {
-    guard();
+    guard2();
     await params.beforeMediaAccess?.();
-    guard();
+    guard2();
   };
   if (message.type === 49 && message.appMessageType === 57) return prepareNativeQuote(params);
   if (message.type === 49 && message.appMessageType === 19) return { body: message.body?.slice(0, 65536) || "[Forwarded chat history unavailable]", pending: false };
@@ -1419,11 +1642,14 @@ 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;
-    guard();
+    guard2();
     if (items.some((asset2) => asset2.accountId !== accountId || asset2.messageId !== message.id)) throw Error("Native attachment identity does not match its message");
     return items;
   };
@@ -1445,9 +1671,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);
-    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");
+    job = await incomingMediaJobStatus(client, accountId, initialCandidate.jobId, initialCandidate.id, params.signal, guard2);
+    guard2();
+    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" };
@@ -1457,11 +1683,17 @@ async function prepareNativeAttachmentInput(params) {
     await authorize();
     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);
-      guard();
+      guard2();
+      job = await waitNativeMediaStatus(
+        job,
+        params.waitMs ?? 2e4,
+        params.signal,
+        guard2,
+        (known, pollSignal) => incomingMediaJobStatus(client, accountId, known.id, initialCandidate?.id, pollSignal, guard2)
+      );
+      guard2();
     } catch (error) {
-      guard();
+      guard2();
       if (!(error instanceof NativeApiError) || terminalIdentityErrors.has(error.code)) throw error;
       if (error.retryable) return { body: `[${attachmentKind} pending: retrieval is unavailable]`, pending: true, jobId: job?.id, retryable: true };
       transferError = error;
@@ -1491,14 +1723,63 @@ 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: guard2,
+        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();
+  guard2();
   const mime = content.contentType.split(";", 1)[0].trim().toLowerCase();
   if (!/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/.test(mime)) throw Error("Native attachment MIME type is unsupported");
   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,
@@ -1518,7 +1799,7 @@ async function prepareNativeAttachmentInput(params) {
       if (!preview || preview.sourceSha256 !== hash || !/^[a-f0-9]{64}$/.test(preview.sha256) || !Number.isInteger(preview.byteLength) || preview.byteLength <= 0 || preview.byteLength > 16 * 1024 * 1024 || !["image/jpeg", "image/png"].includes(preview.contentType)) throw Error("Native WXGF preview metadata did not verify");
       await authorize();
       const derived = await client.mediaContent(accountId, asset.id, { maxBytes: preview.byteLength, representation: "preview", signal: params.signal });
-      guard();
+      guard2();
       const derivedMime = derived.contentType.split(";", 1)[0].trim().toLowerCase();
       if (derived.sourceSha256 !== hash || derivedMime !== preview.contentType || derived.bytes.length !== preview.byteLength || createHash4("sha256").update(derived.bytes).digest("hex") !== preview.sha256) throw Error("Native WXGF preview integrity did not verify");
       imageBytes = Buffer.from(derived.bytes);
@@ -1543,7 +1824,7 @@ async function prepareNativeAttachmentInput(params) {
 [Model image: prepared still preview; original retained separately]`;
     }
   }
-  guard();
+  guard2();
   return {
     body,
     attachment,
@@ -1570,78 +1851,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 +1966,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 +1985,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 guard2 = (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 }, guard2(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, guard2(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 +2103,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 +2233,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 +2242,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 +2313,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 +2322,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 +2341,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 +2356,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);
@@ -2277,17 +2683,17 @@ async function recheckNativeInputs(client, state, messages) {
       throw new NativeInputInvalidated();
     }
     if (message.quote) {
-      const quote = await client.quotedMessage(message.accountId, message.id);
-      if (quote.accountId !== message.accountId || quote.threadId !== message.threadId || quote.messageId !== message.id) throw Error("Native quote identity changed");
-      if (quote.state === "recalled" || quote.message && nativeRecallInfo(quote.message)) {
+      const quote = current.quote;
+      if (quote?.state === "recalled") {
         const affected = state.acceptRecall(state.cursor, {
           threadId: message.threadId,
           serverId: message.quote.serverId,
-          observedAt: quote.message && nativeRecallInfo(quote.message)?.observedAt || (/* @__PURE__ */ new Date()).toISOString()
+          observedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         invalidateNativePreparedInputs(message.accountId, affected);
         throw new NativeInputInvalidated();
       }
+      if (!quote || JSON.stringify(quote) !== JSON.stringify(message.quote)) throw Error("Native embedded quote changed; delivery held for review");
     }
     if (!state.isCurrent(message)) throw new NativeInputInvalidated();
   }
@@ -2444,7 +2850,7 @@ async function dispatchNativeMessageInput(params, revision) {
   });
   assertCurrent();
   state.beginDispatch(message.id, dispatchManifest, buffered.map((item) => item.message.id));
-  const callback = readPolicy !== "on_inbound" && (message.type === 1 || message.type === 49 && message.appMessageType === 19 && !!message.body || message.type === 49 && [3, 4, 5].includes(message.appMessageType ?? 0) && !!message.link || preparedMedia.quote?.type === 1 && ["resolved", "embedded"].includes(preparedMedia.quote.state) || preparedMedia.attachment?.status === "ready" && preparedMedia.suppliedAssets?.length) ? state.preparedCallback([message.id], readPolicy) : void 0;
+  const callback = readPolicy !== "on_inbound" && (message.type === 1 || message.type === 49 && message.appMessageType === 19 && !!message.body || message.type === 49 && [3, 4, 5].includes(message.appMessageType ?? 0) && !!message.link || preparedMedia.quote && [1, 49].includes(preparedMedia.quote.type ?? 0) && ["resolved", "embedded"].includes(preparedMedia.quote.state) || preparedMedia.attachment?.status === "ready" && preparedMedia.suppliedAssets?.length) ? state.preparedCallback([message.id], readPolicy) : void 0;
   if (callback) trackNativePreparedInput(dispatchManifest, callback);
   const beforeSend = () => recheck([message, ...admitted]);
   let failed = false;
@@ -2463,12 +2869,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?.();
@@ -2644,43 +3050,69 @@ async function startNativeMonitor(opts) {
 
 // src/native-login.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
 var operations = /* @__PURE__ */ new Map();
 var terminal = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled", "expired", "rejected", "needs_login"]);
-async function nativeLoginStart(account, options = {}) {
+function guard(access2) {
+  access2.signal?.throwIfAborted();
+  access2.assertCurrent?.();
+}
+function validateOperation(operation, accountId, operationId) {
+  if (operation.accountId !== accountId || operation.kind !== "login" || operationId && operation.id !== operationId) throw Error("Native login operation identity does not match its account");
+}
+async function nativeLoginStart(account, options = {}, access2 = {}) {
+  guard(access2);
   const native = account.native;
-  const { client } = await ensureNativeHost(native);
+  const { client } = await (access2.host ?? ensureNativeHost)(native);
+  guard(access2);
+  const configurationKey = nativeConfigurationKey(native);
   const existing = operations.get(account.accountId);
-  if (existing && existing.accountId === native.accountId && !options.force) {
-    existing.operation = await client.operation(native.accountId, existing.operation.id);
-    if (!terminal.has(existing.operation.state)) return nativeLoginWait(account.accountId, Math.min(options.timeoutMs ?? 3e4, 3e4), true);
-  }
+  if (existing && existing.configurationKey === configurationKey) {
+    const refreshed = await client.operation(native.accountId, existing.operation.id);
+    guard(access2);
+    validateOperation(refreshed, native.accountId, existing.operation.id);
+    existing.operation = refreshed;
+    existing.client = client;
+    if (!terminal.has(existing.operation.state)) return nativeLoginWait(account, Math.min(options.timeoutMs ?? 3e4, 3e4), true, access2);
+  }
+  guard(access2);
   const operation = await client.login(native.accountId, {
     allowQr: true,
     forceQr: options.force === true,
     timeoutSeconds: Math.max(10, Math.min(900, Math.ceil((options.timeoutMs ?? 3e5) / 1e3))),
     computerName: "agent-wechat"
-  });
-  operations.set(account.accountId, { client, accountId: native.accountId, operation });
-  return nativeLoginWait(account.accountId, Math.min(options.timeoutMs ?? 3e4, 3e4), true);
+  }, randomUUID5());
+  validateOperation(operation, native.accountId);
+  operations.set(account.accountId, { client, accountId: native.accountId, configurationKey, operation });
+  guard(access2);
+  return nativeLoginWait(account, Math.min(options.timeoutMs ?? 3e4, 3e4), true, access2);
 }
-async function nativeLoginWait(accountId, timeoutMs = 3e4, stopAtQr = false) {
-  const active2 = operations.get(accountId);
-  if (!active2) return { connected: false, message: "No native login operation; start login first" };
+async function nativeLoginWait(account, timeoutMs = 3e4, stopAtQr = false, access2 = {}) {
+  guard(access2);
+  const active2 = operations.get(account.accountId);
+  if (!active2 || active2.configurationKey !== nativeConfigurationKey(account.native)) return { connected: false, state: "idle", message: "No native login operation; start login first" };
   const deadline = Date.now() + Math.max(1e3, Math.min(timeoutMs, 3e5));
   while (Date.now() < deadline) {
-    active2.operation = await active2.client.operation(active2.accountId, active2.operation.id);
+    guard(access2);
+    const refreshed = await active2.client.operation(active2.accountId, active2.operation.id);
+    guard(access2);
+    validateOperation(refreshed, active2.accountId, active2.operation.id);
+    active2.operation = refreshed;
     const state = active2.operation.state;
-    if (state === "succeeded") return { connected: true, message: "Native login succeeded" };
-    if (terminal.has(state)) return { connected: false, message: `Native login ${state}` };
+    const result = { connected: state === "succeeded", state, operationId: active2.operation.id };
+    if (state === "succeeded") return { ...result, message: "Native login succeeded" };
+    if (terminal.has(state)) return { ...result, message: `Native login ${state}` };
+    if (stopAtQr && state === "awaiting_approval") return { ...result, message: "Approve native login on your phone" };
     if (stopAtQr && active2.operation.result?.qrAvailable === true) {
       const generation = active2.operation.result?.qrGeneration;
       const png = await active2.client.qr(active2.accountId, active2.operation.id, typeof generation === "number" ? generation : void 0);
-      return { connected: false, qrDataUrl: `data:image/png;base64,${Buffer.from(png).toString("base64")}`, message: "Scan the white-background native QR and approve login" };
+      guard(access2);
+      return { ...result, qrDataUrl: `data:image/png;base64,${Buffer.from(png).toString("base64")}`, message: "Scan the white-background native QR and approve login" };
     }
-    if (stopAtQr && state === "awaiting_approval") return { connected: false, message: "Approve native login on your phone" };
-    await new Promise((resolve) => setTimeout(resolve, 500));
+    await delay(Math.min(500, Math.max(0, deadline - Date.now())), void 0, { signal: access2.signal });
   }
-  return { connected: false, message: "Native login remains pending; wait on the same operation rather than starting a replacement" };
+  guard(access2);
+  return { connected: false, state: active2.operation.state, operationId: active2.operation.id, message: "Native login remains pending; wait on the same operation rather than starting a replacement" };
 }
 async function sendNativeText(account, threadId2, text3, key = randomUUID5()) {
   const native = account.native;
@@ -2694,29 +3126,59 @@ async function sendNativeText(account, threadId2, text3, key = randomUUID5()) {
     { sendId: send.id, state: send.state, serverIds: send.serverId ? [send.serverId] : void 0 }
   );
 }
-function createNativeLoginTool(account) {
+function createNativeLoginTool(account, dependencies = {}) {
+  const actions = ["status", "start", "wait", "disconnect", "logout", "forget"];
+  const configurationKey = nativeConfigurationKey(account.native);
   return {
     label: "WeChat Login",
     name: "wechat_login",
-    description: "Inspect/start native login, disconnect retaining trust, or request durable logout. Logout commits local inhibition and reports its native server outcome separately; it does not promise saved-device revocation. Explicitly confirmed forget removes local authentication while retaining history. A QR is returned as an image when available.",
-    parameters: { type: "object", properties: { action: { type: "string", enum: ["status", "start", "disconnect", "logout", "forget"] }, force: { type: "boolean" }, confirm: { type: "boolean" } }, required: ["action"] },
-    execute: async (_id, params) => {
+    catalogMode: "direct-only",
+    description: "Check WeChat status, start or resume native login, or wait for the same login operation. Show the returned QR image to the user to scan and approve on their phone; do not generate a replacement QR. Repeated start reuses an active operation. For a new operation, force uses QR instead of saved trust. timeoutMs bounds the wait. Disconnect retains saved trust. Logout reports its durable native outcome; it does not promise saved-device revocation. Forget requires confirm=true and removes local authentication while retaining history.",
+    parameters: { type: "object", additionalProperties: false, properties: {
+      action: { type: "string", enum: actions },
+      force: { type: "boolean", description: "With start, use QR instead of saved trust for a new login. An active login is still reused." },
+      timeoutMs: { type: "integer", minimum: 1e3, maximum: 3e5, description: "Wait bound in milliseconds; defaults to 30000. Start returns as soon as a QR is available." },
+      confirm: { type: "boolean", description: "Required true for forget." }
+    }, required: ["action"] },
+    execute: async (_id, params, signal) => {
+      if (!params || typeof params !== "object" || Array.isArray(params)) throw Error("Expected login arguments");
       const args = params;
-      const native = account.native;
-      const { client } = await ensureNativeHost(native);
-      if (args.action === "start") {
-        const result2 = await nativeLoginStart(account, { force: args.force });
+      if (Object.keys(args).some((key) => !["action", "force", "timeoutMs", "confirm"].includes(key)) || !actions.includes(args.action) || args.force !== void 0 && typeof args.force !== "boolean" || args.confirm !== void 0 && typeof args.confirm !== "boolean" || args.timeoutMs !== void 0 && (!Number.isSafeInteger(args.timeoutMs) || args.timeoutMs < 1e3 || args.timeoutMs > 3e5)) throw Error("Invalid native login arguments");
+      if (args.action === "forget" && args.confirm !== true) throw Error("Forgetting native credentials requires confirm=true");
+      const access2 = { host: dependencies.host, signal, assertCurrent: () => {
+        dependencies.context?.assertInvocationCurrent?.();
+        if (!dependencies.context) return;
+        const context = dependencies.context;
+        const config = context.getRuntimeConfig?.() ?? context.runtimeConfig ?? context.config;
+        const current = config && resolveWeChatAccount(config);
+        if (!current?.enabled || !current.native || nativeConfigurationKey(current.native) !== configurationKey) throw Error("Native login configuration changed; invoke the tool again");
+      } };
+      guard(access2);
+      if (args.action === "start" || args.action === "wait") {
+        const result2 = args.action === "start" ? await nativeLoginStart(account, { force: args.force, timeoutMs: args.timeoutMs }, access2) : await nativeLoginWait(account, args.timeoutMs, false, access2);
         const content = [{ type: "text", text: result2.message }];
         if (result2.qrDataUrl) content.push({ type: "image", data: result2.qrDataUrl.split(",")[1], mimeType: "image/png" });
-        return { content, details: { connected: result2.connected } };
+        return { content, details: { connected: result2.connected, state: result2.state, operationId: result2.operationId } };
       }
+      const native = account.native;
+      const { client } = await (access2.host ?? ensureNativeHost)(native);
+      guard(access2);
       const result = args.action === "status" ? await client.account(native.accountId) : args.action === "disconnect" ? await client.disconnect(native.accountId) : args.action === "logout" ? await client.logout(native.accountId, randomUUID5()) : args.action === "forget" && args.confirm === true ? await client.forgetCredentials(native.accountId, randomUUID5(), true) : (() => {
         throw new Error("Unknown native login action");
       })();
+      if (args.action !== "status") operations.delete(account.accountId);
+      guard(access2);
       return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
     }
   };
 }
+function registerNativeLoginTool(api) {
+  api.registerTool({ contextVersion: 2, create: (context) => {
+    const config = context.getRuntimeConfig?.() ?? context.runtimeConfig ?? context.config;
+    const account = config && resolveWeChatAccount(config);
+    return account?.enabled && account.native ? [createNativeLoginTool(account, { context })] : [];
+  } }, { names: ["wechat_login"] });
+}
 
 // src/channel.ts
 async function sendWeChatText(cfg, to, text3) {
@@ -2724,6 +3186,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 +3199,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 +3223,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 +3345,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: {
@@ -2917,7 +3375,7 @@ var wechatPlugin = {
     loginWithQrWait: async ({ accountId, timeoutMs }) => {
       const account = resolveWeChatAccount(getWeChatRuntime().config.current(), accountId ?? void 0);
       if (!account?.native) return { connected: false, message: "No native daemon configured" };
-      return nativeLoginWait(account.accountId, timeoutMs);
+      return nativeLoginWait(account, timeoutMs);
     }
   },
   auth: {
@@ -2943,10 +3401,6 @@ var wechatPlugin = {
       linked: runtime2?.linked ?? false
     })
   },
-  agentTools: (({ cfg }) => {
-    const account = resolveWeChatAccount(cfg);
-    return account?.native ? [createNativeLoginTool(account)] : [];
-  }),
   directory: {
     self: async ({ cfg }) => {
       const account = resolveWeChatAccount(cfg);
@@ -3054,7 +3508,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 +3521,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 +3550,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 +3574,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,14 +3618,14 @@ 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) {
   return string(string(value, "thread ID").replace(/^(?:agent-)?wechat:(?:group:)?/i, ""), "thread ID");
 }
-function messageResult(message, retrievalTool = "wechat_media") {
+function messageResult(message, retrievalTool = "wechat_media", quotePermitted = false) {
   if (nativeRecallInfo(message)) return {
     id: message.id,
     threadId: message.threadId,
@@ -3176,8 +3640,15 @@ function messageResult(message, retrievalTool = "wechat_media") {
   const isForward = message.type === 49 && message.appMessageType === 19;
   const isLink = message.type === 49 && [3, 4, 5].includes(message.appMessageType ?? 0) && !!message.link;
   const kind2 = isQuote ? "quote" : isForward ? "forwarded_history" : isLink ? "link_preview" : message.type === 3 ? "image" : message.type === 47 ? "sticker" : message.type === 34 ? "voice" : message.type === 43 ? "video" : message.type === 49 && (message.appMessageType == null || message.appMessageType === 6) ? "file" : "unsupported";
-  const body = message.type === 1 || isForward || isLink ? message.body ?? "" : isQuote ? `${message.body ?? ""}
-[Quoted original not retrieved; use ${retrievalTool} with this message ID]` : `[WeChat ${kind2} message; attachment content has not been retrieved by this tool]`;
+  const body = message.type === 1 || isForward || isLink ? message.body ?? "" : isQuote ? renderEmbeddedQuote(message, quotePermitted).body : `[WeChat ${kind2} message; attachment content has not been retrieved by this tool]`;
+  const quote = message.quote && {
+    serverId: message.quote.serverId,
+    type: message.quote.type,
+    state: quotePermitted ? message.quote.state : "not permitted",
+    senderId: message.quote.senderId,
+    appMessageType: message.quote.appMessageType,
+    embeddedImage: quotePermitted ? message.quote.embeddedImage : void 0
+  };
   return {
     id: message.id,
     threadId: message.threadId,
@@ -3186,7 +3657,7 @@ function messageResult(message, retrievalTool = "wechat_media") {
     direction: message.direction,
     type: message.type,
     appMessageType: message.appMessageType,
-    quote: message.quote,
+    quote,
     link: isLink ? message.link : void 0,
     createdAt: message.createdAt,
     body: body.slice(0, 4e3),
@@ -3227,9 +3698,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.
@@ -3237,7 +3708,7 @@ function createLookupTools(context, dependencies, archive) {
     parameters: { type: "object", additionalProperties: false, properties, required },
     execute: async (_callId, input, signal) => {
       const args = object(input);
-      const guard = () => {
+      const guard2 = () => {
         signal?.throwIfAborted();
         context.assertInvocationCurrent?.();
         const cfg2 = currentConfig();
@@ -3245,7 +3716,7 @@ function createLookupTools(context, dependencies, archive) {
         if (!account2?.enabled || !account2.native || account2.native.accountId !== selectedId || account2.accountId !== selected.accountId || nativeConfigurationKey(account2.native) !== configurationKey) throw Error("WeChat account configuration changed; start a new turn");
         return { cfg: cfg2, account: account2, native: account2.native };
       };
-      const { cfg, account, native } = guard();
+      const { cfg, account, native } = guard2();
       if (Object.keys(args).some((key) => !Object.hasOwn(properties, key))) throw Error(archive ? "Unknown archive lookup argument" : "Unknown lookup argument; WeChat history is restricted to the current conversation");
       const limit = args.limit ?? 20;
       if (!Number.isInteger(limit) || limit < 1 || limit > 50) throw Error("limit must be 1\u201350");
@@ -3262,7 +3733,7 @@ function createLookupTools(context, dependencies, archive) {
       const core = dependencies.core ?? getWeChatRuntime();
       const allowed = async (sender) => {
         if (archive) return true;
-        const { cfg: cfg2, account: account2 } = guard();
+        const { cfg: cfg2, account: account2 } = guard2();
         const result2 = await resolveWeChatIngress({
           resolve: core.channel.inbound?.ingress?.resolveStable ?? resolveStableChannelMessageIngress2,
           cfg: cfg2,
@@ -3276,10 +3747,15 @@ function createLookupTools(context, dependencies, archive) {
         return result2.ingress.admission === "dispatch";
       };
       if (!await allowed(requesterSenderId)) throw Error("WeChat conversation access is no longer allowed");
-      guard();
+      guard2();
       const { client } = await (dependencies.host ?? ensureNativeHost)(native);
-      guard();
+      guard2();
       const accountId = native.accountId;
+      const visibleMessage = async (message) => messageResult(
+        message,
+        archive ? "wechat_archive_media" : "wechat_media",
+        !message.quote || archive || message.quote.direction === "outgoing" || !!message.quote.senderId && await allowed(message.quote.senderId)
+      );
       let result;
       if (action === "threads") {
         const page = await client.threads(accountId, { limit, cursor, ...query ? { query } : {} });
@@ -3292,21 +3768,20 @@ function createLookupTools(context, dependencies, archive) {
         result = { ...page, items, scope: "local_profile", note: "Locally stored threads; coverage may be partial. This lookup does not mark threads read." };
       } else if (action === "message" || action === "media") {
         const message = await client.message(accountId, messageId);
-        guard();
+        guard2();
         if (!await allowed(requesterSenderId)) throw Error("WeChat conversation access is no longer allowed");
         if (message.id !== messageId || message.accountId !== accountId || !archive && message.threadId !== conversation || message.direction !== "outgoing" && !await allowed(message.senderId ?? void 0)) throw Error("Message is outside the permitted conversation or sender policy");
-        result = messageResult(message, archive ? "wechat_archive_media" : "wechat_media");
+        if (action === "message") result = await visibleMessage(message);
         if (action === "media") {
           const checkRecall = async () => {
-            guard();
+            guard2();
             const latest = await client.message(accountId, messageId);
-            guard();
+            guard2();
             if (latest.id !== message.id || latest.accountId !== accountId || latest.threadId !== message.threadId || latest.serverId !== message.serverId) throw Error("Native media message identity changed");
             if (nativeRecallInfo(latest)) throw new NativeApiError(410, "message_recalled", false);
             if (message.quote) {
-              const quote = await client.quotedMessage(accountId, message.id);
-              guard();
-              if (quote.state === "recalled" || quote.message && nativeRecallInfo(quote.message)) throw new NativeApiError(410, "message_recalled", false);
+              if (latest.quote?.state === "recalled") throw new NativeApiError(410, "message_recalled", false);
+              if (!latest.quote || JSON.stringify(latest.quote) !== JSON.stringify(message.quote)) throw new NativeApiError(409, "media_source_changed", false);
             }
           };
           let prepared;
@@ -3321,7 +3796,7 @@ function createLookupTools(context, dependencies, archive) {
               download: args.download !== false,
               waitMs: 2e3,
               signal,
-              assertCurrent: guard,
+              assertCurrent: guard2,
               allowQuotedMessage: async (original) => original.direction === "outgoing" || await allowed(original.senderId ?? void 0),
               beforeMediaAccess: async () => {
                 if (!await allowed(requesterSenderId) || message.direction !== "outgoing" && !await allowed(message.senderId ?? void 0)) throw Error("WeChat conversation access is no longer allowed");
@@ -3329,7 +3804,7 @@ function createLookupTools(context, dependencies, archive) {
               }
             });
           } catch (error) {
-            guard();
+            guard2();
             if (!(error instanceof NativeApiError)) throw error;
             const details2 = {
               messageId: message.id,
@@ -3340,7 +3815,7 @@ function createLookupTools(context, dependencies, archive) {
             };
             return { content: [{ type: "text", text: JSON.stringify(details2) }], details: details2 };
           }
-          guard();
+          guard2();
           if (!await allowed(requesterSenderId) || message.direction !== "outgoing" && !await allowed(message.senderId ?? void 0)) throw Error("WeChat conversation access is no longer allowed");
           const details = {
             messageId: message.id,
@@ -3357,7 +3832,7 @@ function createLookupTools(context, dependencies, archive) {
           };
           const image = prepared.suppliedAssets?.find((asset) => asset.role === "model_image");
           const output = image ? await imageResultFromFile({ label: "WeChat attachment", path: image.path, extraText: JSON.stringify(details), details }) : { content: [{ type: "text", text: JSON.stringify(details) }], details };
-          guard();
+          guard2();
           try {
             await checkRecall();
           } catch (error) {
@@ -3374,7 +3849,7 @@ function createLookupTools(context, dependencies, archive) {
         for (const message of page.items) {
           if (isNativeTombstone(message)) continue;
           if (conversation && message.threadId !== conversation || message.accountId !== accountId) throw Error("WeChat history response crosses a conversation boundary");
-          if (message.direction === "outgoing" || await allowed(message.senderId ?? void 0)) items.push(messageResult(message, archive ? "wechat_archive_media" : "wechat_media"));
+          if (message.direction === "outgoing" || await allowed(message.senderId ?? void 0)) items.push(await visibleMessage(message));
         }
         result = {
           ...page,
@@ -3384,7 +3859,7 @@ function createLookupTools(context, dependencies, archive) {
           note: archive ? "Account-wide local history may be partial. These reads do not mark threads read or download attachments." : "Local history may be partial. A filtered page can be empty with a nextCursor. These reads do not mark a conversation read or download attachments."
         };
       }
-      guard();
+      guard2();
       return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
     }
   });
@@ -3399,13 +3874,13 @@ function createLookupTools(context, dependencies, archive) {
     tool(archiveNames[1], "search", "Search locally stored messages across every thread in the configured WeChat account, including other senders. Optional threadId narrows the search. Follow nextCursor with the same query and thread selection; no remote backfill or read marking.", { query: querySchema, threadId: messageIdSchema, ...pageSchema }, ["query"]),
     tool(archiveNames[2], "history", "Read the locally stored history of any thread in the configured WeChat account, newest first, without sender filtering or read marking. Use wechat_archive_threads to find thread IDs.", { threadId: messageIdSchema, ...pageSchema }, ["threadId"]),
     tool(archiveNames[3], "message", "Look up a stored message in any thread of the configured WeChat account by its exact opaque message ID. Use wechat_archive_media to retrieve its attachment.", { messageId: messageIdSchema }, ["messageId"]),
-    tool(archiveNames[4], "media", "Retrieve an attachment or quoted text/image from any thread in the configured WeChat account by its message ID. Use the parent quote message ID for quotes. Returns verified managed file paths and an image preview for vision. Cached bytes first; missing media requests a bounded server-owned download unless download=false. Preserve pending/expired/unavailable results and never automatically retry retryable=false. No sends or read marking.", mediaSchema, ["messageId"])
+    tool(archiveNames[4], "media", "Retrieve an attachment or quoted text/image/link from any thread in the configured WeChat account by its message ID. Use the parent quote message ID for quotes. Returns verified managed file paths and an image preview for vision. Cached bytes first; missing media requests a bounded server-owned download unless download=false. Preserve pending/expired/unavailable results and never automatically retry retryable=false. No sends or read marking.", mediaSchema, ["messageId"])
   ];
   return [
     tool(names[0], "history", "Read the current WeChat conversation's locally stored messages, newest first, beyond the recent inbound buffer. Follow nextCursor for older history; no remote history backfill or read marking.", { ...pageSchema }),
     tool(names[1], "search", "Search the current WeChat conversation's locally stored message text by case-insensitive substring, beyond buffered messages. Follow nextCursor with the same query in this conversation.", { query: querySchema, ...pageSchema }, ["query"]),
     tool(names[2], "message", "Look up a stored message by its exact opaque message ID in the current WeChat conversation. Media is described without downloading it; use wechat_media to retrieve its attachment. Long text is bounded.", { messageId: messageIdSchema }, ["messageId"]),
-    tool(names[3], "media", "Retrieve a message attachment or quoted text/image from the current WeChat conversation. Use the parent quote message ID for quotes. Returns a verified local file path and an image preview for vision when applicable. Uses cached bytes first; download defaults to true and requests a bounded server-owned transfer if missing. Pending results may be checked again; never automatically retry confirmed expiry or retryable=false. Does not send messages or mark the thread read.", mediaSchema, ["messageId"])
+    tool(names[3], "media", "Retrieve a message attachment or quoted text/image/link from the current WeChat conversation. Use the parent quote message ID for quotes. Returns a verified local file path and an image preview for vision when applicable. Uses cached bytes first; download defaults to true and requests a bounded server-owned transfer if missing. Pending results may be checked again; never automatically retry confirmed expiry or retryable=false. Does not send messages or mark the thread read.", mediaSchema, ["messageId"])
   ];
 }
 function registerNativeHistoryTools(api) {
@@ -3471,7 +3946,7 @@ function createNativeShareTools(context, dependencies = {}) {
         ...args.description !== void 0 ? { description: args.description === "" ? "" : text(args.description, "description", 16384, true) } : {},
         ...args.thumbnailUrl !== void 0 ? { thumbnailUrl: url(args.thumbnailUrl, "thumbnail URL") } : {}
       };
-      const guard = () => {
+      const guard2 = () => {
         signal?.throwIfAborted();
         context.assertInvocationCurrent?.();
         const cfg = currentConfig(), account = resolveWeChatAccount(cfg);
@@ -3480,7 +3955,7 @@ function createNativeShareTools(context, dependencies = {}) {
       };
       const core = dependencies.core ?? getWeChatRuntime();
       const authorize = async () => {
-        const { cfg, account } = guard();
+        const { cfg, account } = guard2();
         const result = await resolveWeChatIngress({
           resolve: core.channel.inbound?.ingress?.resolveStable ?? resolveStableChannelMessageIngress3,
           cfg,
@@ -3491,11 +3966,11 @@ function createNativeShareTools(context, dependencies = {}) {
           senderId: requester,
           readStoreAllowFrom: async () => core.channel.pairing.readAllowFromStore({ channel: "agent-wechat", accountId: account.accountId, env: process.env }).catch(() => [])
         });
-        guard();
+        guard2();
         if (result.ingress.admission !== "dispatch") throw Error("WeChat conversation access is no longer allowed");
       };
       await authorize();
-      const { native } = guard();
+      const { native } = guard2();
       const { client } = await (dependencies.host ?? ensureNativeHost)(native);
       await authorize();
       let intent;
@@ -3530,7 +4005,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 +4016,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;
@@ -3573,7 +4048,7 @@ function createNativeRecallTools(context, dependencies = {}) {
       const messageId = text2(input.messageId, "message ID");
       const serverId = text2(input.serverId, "server ID");
       if (!/^[1-9]\d{0,19}$/.test(serverId) || BigInt(serverId) > 18446744073709551615n) throw Error("Invalid exact server message ID");
-      const guard = () => {
+      const guard2 = () => {
         signal?.throwIfAborted();
         context.assertInvocationCurrent?.();
         const cfg = currentConfig(), account = resolveWeChatAccount(cfg);
@@ -3581,7 +4056,7 @@ function createNativeRecallTools(context, dependencies = {}) {
         return { cfg, account, native: account.native };
       };
       const allowed = async () => {
-        const { cfg, account } = guard();
+        const { cfg, account } = guard2();
         const core = dependencies.core ?? getWeChatRuntime();
         const ingress = await resolveWeChatIngress({
           resolve: core.channel.inbound?.ingress?.resolveStable ?? resolveStableChannelMessageIngress4,
@@ -3593,20 +4068,20 @@ function createNativeRecallTools(context, dependencies = {}) {
           senderId: requester,
           readStoreAllowFrom: async () => core.channel.pairing.readAllowFromStore({ channel: "agent-wechat", accountId: account.accountId, env: process.env }).catch(() => [])
         });
-        guard();
+        guard2();
         if (ingress.ingress.admission !== "dispatch") throw Error("WeChat conversation access is no longer allowed");
       };
       await allowed();
-      const { native } = guard();
+      const { native } = guard2();
       const { client } = await (dependencies.host ?? ensureNativeHost)(native);
-      guard();
+      guard2();
       const message = await client.message(accountId, messageId);
-      guard();
+      guard2();
       const retainedRecall = !!nativeRecallInfo(message);
       if (message.id !== messageId || message.accountId !== accountId || message.threadId !== conversation || message.direction !== "outgoing" && !retainedRecall) throw Error("Recall target is outside this conversation or was not sent by this account");
       if (message.serverId !== serverId) throw Error("The exact server identity does not match this receipt; the local message identity may have been reused");
       await allowed();
-      guard();
+      guard2();
       const key = nativeRecallKey(accountId, conversation, messageId, serverId);
       let operation;
       let operationId;
@@ -3636,13 +4111,13 @@ function createNativeRecallTools(context, dependencies = {}) {
         const deadline = Date.now() + Math.max(0, Math.min(dependencies.waitMs ?? 2e3, 1e4));
         while (["queued", "running", "submitting"].includes(operation.state) && Date.now() < deadline) {
           await new Promise((resolve) => setTimeout(resolve, Math.min(250, deadline - Date.now())));
-          guard();
+          guard2();
           const remaining = Math.max(1, deadline - Date.now());
           const next = await client.operation(accountId, operation.id, signal ? AbortSignal.any([signal, AbortSignal.timeout(remaining)]) : AbortSignal.timeout(remaining));
           checkOperation(next);
           operation = next;
         }
-        guard();
+        guard2();
       } catch (error) {
         const reason = error instanceof NativeApiError ? error.code : "recall_result_unavailable";
         return result("needs_review", { reason, note: "Inspect the existing operation or repeat only this same message with the same idempotency key. No automatic second submission was made." });
@@ -3664,6 +4139,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 guard2 = () => {
+        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 = guard2();
+      const { client } = await (dependencies.host ?? ensureNativeHost)(native);
+      guard2();
+      const group = await client.group(accountId, args.groupId, signal);
+      guard2();
+      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);
+      guard2();
+      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 +4201,8 @@ var plugin = {
     registerNativeHistoryTools(api);
     registerNativeShareTools(api);
     registerNativeRecallTools(api);
+    registerNativeGroupTools(api);
+    registerNativeLoginTool(api);
     const stopFacade = selected?.native ? registerNativeFacade(api, selected.native) : () => {
     };
     const stopPreparedBoundary = selected?.native?.readPolicy && selected.native.readPolicy !== "on_inbound" ? registerNativePreparedBoundary(api) : () => {