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

package/README.md

@@ -23,6 +23,12 @@ Configure plugin defaults under `plugins.entries.agent-wechat.config` (or the sa
 
 The external service remains independently owned. Plugin stop closes its stream and never stops/logs out the daemon or cancels its sends. Remote endpoints require verified HTTPS or an encrypted tunnel terminating at loopback. Set `AGENT_WECHAT_TOKEN` in the Gateway process environment, or use a configured OpenClaw secret provider. The plugin resolves `native.token` through the pinned OpenClaw SDK; `native.tokenFile` is removed. Tokens contain 32–1024 printable ASCII bytes without spaces. An explicit unresolved reference fails startup without falling back to another token. The API token needs read/media/send/login for the selected account, plus read-state only when automatic whole-thread read marking is enabled; do not grant admin solely to run the plugin. Normal sender/DM/group/mention policy remains in `channels.agent-wechat`; defaults remain closed.
 
+## Login tool
+
+`wechat_login` is available to configured agents through OpenClaw's tool policy, including from other channels while WeChat is offline. Use `{"action":"status"}` to inspect the account, `{"action":"start"}` to start or resume login and display the returned QR image, then `{"action":"wait","timeoutMs":30000}` to check scan/approval completion. Repeated starts reuse the pending operation. For a new operation, `force: true` uses QR instead of saved trust. Waits are bounded and report the operation ID and state. Cancelling a tool call leaves the submitted login operation available for a later call.
+
+The tool also accepts `disconnect` (retain saved trust), `logout` (durable native logout) and `forget` with `confirm: true` (remove local authentication, retain history). It stays bound to the configured daemon/account. Apply OpenClaw tool allow/deny policies to control which agents can manage login. The tool is directly callable so the daemon's PNG reaches the model as image content.
+
 ## Native managed mode
 
 ```json
@@ -80,6 +86,8 @@ Native text, image, file, video and voice delivery results return actual stored
 
 Incoming `message.recalled` events are consumed independently of slow media and model work, including recalls of own or unmentioned messages. The consumer persists the event cursor together with a tombstone, removes recalled body/quote content and attachment references from its custody records, and invalidates pending model proofs. Tombstones survive restart and suppress a late original. Attachment retrieval, transcription, model dispatch and later automatic reply delivery recheck the selected messages so late work cannot reinsert recalled input. A quote's unrelated comment remains available after its recalled original is removed.
 
+Received quotes use the parsed embedded content delivered by WeChat's server protocol and included in the normal message response's `quote` field. Text and link details render immediately; image metadata can retrieve verified bytes under the reply's own message ID. Other quoted media keeps the current comment and an unavailable attachment status. Local recall suppression and quoted-author admission still apply, including in history tools. A stored original never replaces the embedded excerpt; quote display needs no separate quote endpoint.
+
 If a source-local message ID later names a different exact thread/server target, the consumer admits that new message with a separate host turn and reply key. Completion callbacks, media results and read receipts captured for the old target cannot overwrite the new custody record.
 
 Stored-history tools return a recalled placeholder; media tools return terminal `status: "recalled"`, `reason: "message_recalled"`, `retryable: false` without attachment paths or image blocks. Recall does not erase an already submitted model input, an existing OpenClaw transcript, a completed action, or attachment bytes retained by OpenClaw's storage policy. An affected in-flight turn is held for review and its later automatic reply is suppressed; the plugin does not claim retroactive transcript correction.

package/dist/index.js

@@ -192,7 +192,7 @@ var NativeWeChatClient = class {
     if (typeof options.token !== "string" || !options.token || /[\r\n]/.test(options.token))
       throw new Error("Native API bearer token is required");
     this.token = options.token;
-    this.fetchImpl = options.fetch ?? fetch;
+    this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
     this.timeoutMs = options.timeoutMs ?? 3e4;
     this.mediaTimeoutMs = options.mediaTimeoutMs ?? 60 * 6e4;
     if (!Number.isInteger(this.mediaTimeoutMs) || this.mediaTimeoutMs < 1 || this.mediaTimeoutMs > 60 * 6e4)
@@ -279,9 +279,22 @@ var NativeWeChatClient = class {
       throw new Error("Account ID or alias is required");
     return this.request("v1/accounts", { method: "POST", body: JSON.stringify(body) });
   }
+  removeAccount(accountId, confirmAccountId) {
+    if (accountId !== confirmAccountId)
+      throw new Error("Account confirmation does not match");
+    return this.request(`v1/accounts/${id(accountId)}`, { method: "DELETE", body: JSON.stringify({ confirmAccountId }) });
+  }
   updateAccount(accountId, options) {
     return this.request(`v1/accounts/${id(accountId)}`, { method: "PATCH", body: JSON.stringify(options) });
   }
+  accountSettings(accountId, signal) {
+    return this.request(`v1/accounts/${id(accountId)}/settings`, { signal });
+  }
+  updateAccountSettings(accountId, settings, signal) {
+    if (!Number.isSafeInteger(settings.autoDownloadMaxBytes) || settings.autoDownloadMaxBytes < 0 || settings.autoDownloadMaxBytes > NATIVE_MAX_SOURCE_BYTES)
+      throw new Error("Invalid automatic download limit");
+    return this.request(`v1/accounts/${id(accountId)}/settings`, { method: "PATCH", body: JSON.stringify(settings), signal });
+  }
   capabilities(accountId) {
     return this.request(`v1/accounts/${id(accountId)}/capabilities`);
   }
@@ -452,15 +465,6 @@ var NativeWeChatClient = class {
     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", "recalled"].includes(quote.state) || (quote.state === "resolved" ? !quote.message || quote.message.accountId !== accountId || quote.message.threadId !== quote.threadId || quote.message.id === messageId : quote.message != null))
-      throw new Error("Invalid native quote identity");
-    if (quote.message)
-      validateMessageRecall(quote.message);
-    return quote;
-  }
   /** Account-wide local search, with the daemon's query-bound opaque cursor. */
   async searchMessages(accountId, options) {
     const result = await this.request(`v1/accounts/${id(accountId)}/messages${listQuery(options)}`);
@@ -638,7 +642,7 @@ var NativeWeChatClient = class {
   ack(accountId, consumerId, cursor) {
     return this.request(`v1/accounts/${id(accountId)}/consumers/${id(consumerId)}/ack`, { method: "POST", body: JSON.stringify({ cursor: decimal(cursor) }) });
   }
-  async *watch(accountId, after = "0", signal) {
+  async *watch(accountId, after = "0", signal, options = {}) {
     const connection = new AbortController();
     const streamSignal = signal ? AbortSignal.any([signal, connection.signal]) : connection.signal;
     const bounded = async (work, milliseconds, reason) => {
@@ -680,6 +684,7 @@ var NativeWeChatClient = class {
         const { value, done } = await bounded(() => activeReader.read(), this.streamIdleTimeoutMs, "Native SSE idle timeout");
         if (done)
           break;
+        options.onActivity?.();
         buffer += decoder.decode(value, { stream: true });
         if (buffer.length > 1024 * 1024)
           throw new Error("Native SSE frame exceeds its bound");
@@ -1337,13 +1342,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;
@@ -1396,6 +1401,34 @@ function recalledNativeMessage(message, recall) {
   };
 }
 
+// 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 }
+  };
+}
+
 // src/native-media.ts
 function kind(type) {
   return type === 3 || type === 47 ? "image" : type === 34 ? "audio" : type === 43 ? "video" : type === 49 ? "file" : void 0;
@@ -1438,11 +1471,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;
@@ -1453,7 +1486,7 @@ 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;
 }
@@ -1463,11 +1496,11 @@ async function waitNativeMediaJob(client, accountId, initial, timeoutMs = 65e3,
 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();
@@ -1475,7 +1508,7 @@ async function waitNativeMediaStatus(initial, timeoutMs, signal, assertCurrent,
     const next = await readStatus(job, signal ? AbortSignal.any([signal, AbortSignal.timeout(remaining)]) : AbortSignal.timeout(remaining));
     if (!next) break;
     job = next;
-    delay = Math.min(delay * 2, 1e3);
+    delay2 = Math.min(delay2 * 2, 1e3);
   }
   return job;
 }
@@ -1551,83 +1584,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) {
@@ -1652,16 +1639,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 };
@@ -1676,7 +1663,7 @@ async function prepareNativeAttachmentInput(params) {
   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;
   };
@@ -1698,8 +1685,8 @@ async function prepareNativeAttachmentInput(params) {
   let transferError;
   if (!asset && initialCandidate?.jobId && initialCandidate.state !== "recalled") {
     await authorize();
-    job = await incomingMediaJobStatus(client, accountId, initialCandidate.jobId, initialCandidate.id, params.signal, guard);
-    guard();
+    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);
@@ -1710,17 +1697,17 @@ async function prepareNativeAttachmentInput(params) {
     await authorize();
     try {
       job = await client.transferMedia(accountId, { messageId: message.id, assetId: null, quality: transferQuality });
-      guard();
+      guard2();
       job = await waitNativeMediaStatus(
         job,
         params.waitMs ?? 2e4,
         params.signal,
-        guard,
-        (known, pollSignal) => incomingMediaJobStatus(client, accountId, known.id, initialCandidate?.id, pollSignal, guard)
+        guard2,
+        (known, pollSignal) => incomingMediaJobStatus(client, accountId, known.id, initialCandidate?.id, pollSignal, guard2)
       );
-      guard();
+      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;
@@ -1766,7 +1753,7 @@ async function prepareNativeAttachmentInput(params) {
         maxBytes,
         expectedBytes: asset.byteLength,
         expectedSha256: asset.sha256 ?? "",
-        assertCurrent: guard,
+        assertCurrent: guard2,
         saveMediaStream: params.saveMediaStream ?? saveMediaStream
       });
     } finally {
@@ -1800,7 +1787,7 @@ async function prepareNativeAttachmentInput(params) {
     };
   }
   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");
@@ -1826,7 +1813,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);
@@ -1851,7 +1838,7 @@ async function prepareNativeAttachmentInput(params) {
 [Model image: prepared still preview; original retained separately]`;
     }
   }
-  guard();
+  guard2();
   return {
     body,
     attachment,
@@ -2056,7 +2043,7 @@ var NativeMediaPayloadInspectionError = class extends Error {
 };
 function createWeChatMediaHandlers(send = sendWeChatMedia) {
   const key = (ctx, index = 0) => ctx.deliveryQueueId ? createHash6("sha256").update(JSON.stringify(["wechat-media", ctx.deliveryQueueId, ctx.deliveryPartIndex ?? 0, index])).digest("hex") : void 0;
-  const guard = (ctx) => async () => {
+  const guard2 = (ctx) => async () => {
     ctx.signal?.throwIfAborted();
     await ctx.onPlatformSendDispatch?.();
     ctx.signal?.throwIfAborted();
@@ -2065,7 +2052,7 @@ function createWeChatMediaHandlers(send = sendWeChatMedia) {
   return {
     sendMedia: async (ctx) => ({
       channel: "agent-wechat",
-      ...await send(ctx.cfg, ctx.to, ctx.text, ctx.mediaUrl, ctx.audioAsVoice, key(ctx), { forceDocument: ctx.forceDocument }, guard(ctx))
+      ...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 };
@@ -2077,7 +2064,7 @@ function createWeChatMediaHandlers(send = sendWeChatMedia) {
       for (const [index, mediaUrl] of (urls.length ? urls : [void 0]).entries()) {
         let delivered;
         try {
-          delivered = await send(ctx.cfg, ctx.to, index === 0 ? ctx.payload.text ?? ctx.text : "", mediaUrl, audioAsVoice, key(ctx, index), options, guard(ctx));
+          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);
@@ -2710,17 +2697,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();
   }
@@ -2877,7 +2864,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;
@@ -3077,43 +3064,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;
@@ -3127,29 +3140,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) {
@@ -3346,7 +3389,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: {
@@ -3372,10 +3415,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);
@@ -3600,7 +3639,7 @@ function string(value, name3, max = 4096) {
 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,
@@ -3615,8 +3654,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,
@@ -3625,7 +3671,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),
@@ -3676,7 +3722,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();
@@ -3684,7 +3730,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");
@@ -3701,7 +3747,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,
@@ -3715,10 +3761,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 } : {} });
@@ -3731,21 +3782,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;
@@ -3760,7 +3810,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");
@@ -3768,7 +3818,7 @@ function createLookupTools(context, dependencies, archive) {
               }
             });
           } catch (error) {
-            guard();
+            guard2();
             if (!(error instanceof NativeApiError)) throw error;
             const details2 = {
               messageId: message.id,
@@ -3779,7 +3829,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,
@@ -3796,7 +3846,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) {
@@ -3813,7 +3863,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,
@@ -3823,7 +3873,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 };
     }
   });
@@ -3838,13 +3888,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) {
@@ -3910,7 +3960,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);
@@ -3919,7 +3969,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,
@@ -3930,11 +3980,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;
@@ -4012,7 +4062,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);
@@ -4020,7 +4070,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,
@@ -4032,20 +4082,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;
@@ -4075,13 +4125,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." });
@@ -4127,7 +4177,7 @@ function createNativeGroupTools(context, dependencies = {}) {
       const args = input;
       const identity = (value) => typeof value === "string" && value.length > 0 && value.length <= 256 && !/[\s\u0000-\u001f\u007f]/u.test(value);
       if (!identity(args.groupId) || !args.groupId.endsWith("@chatroom") || args.groupId.length <= 9 || args.limit != null && (!Number.isInteger(args.limit) || Number(args.limit) < 1 || Number(args.limit) > 100) || args.cursor != null && (typeof args.cursor !== "string" || args.cursor.length > 8192) || args.username != null && !identity(args.username) || args.username != null && (args.limit != null || args.cursor != null)) throw Error("Invalid group info selectors");
-      const guard = () => {
+      const guard2 = () => {
         signal?.throwIfAborted();
         if (context.senderIsOwner !== true) throw Error("OpenClaw owner authorization is required");
         context.assertInvocationCurrent();
@@ -4135,14 +4185,14 @@ function createNativeGroupTools(context, dependencies = {}) {
         if (!account?.enabled || !account.native || account.accountId !== selected.accountId || account.native.accountId !== accountId || nativeConfigurationKey(account.native) !== configurationKey) throw Error("WeChat account configuration changed; start a new turn");
         return account.native;
       };
-      const native = guard();
+      const native = guard2();
       const { client } = await (dependencies.host ?? ensureNativeHost)(native);
-      guard();
+      guard2();
       const group = await client.group(accountId, args.groupId, signal);
-      guard();
+      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);
-      guard();
+      guard2();
       const details = { accountId, group, members, source: "cached", membershipAbsence: "unconfirmed" };
       return { content: [{ type: "text", text: JSON.stringify(details) }], details };
     }
@@ -4166,6 +4216,7 @@ var plugin = {
     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) : () => {

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "agent-wechat",
   "contracts": {
-    "tools": ["wechat_history", "wechat_search", "wechat_message", "wechat_media", "wechat_archive_threads", "wechat_archive_search", "wechat_archive_history", "wechat_archive_message", "wechat_archive_media", "wechat_recall", "wechat_send_share", "wechat_group_info"]
+    "tools": ["wechat_history", "wechat_search", "wechat_message", "wechat_media", "wechat_archive_threads", "wechat_archive_search", "wechat_archive_history", "wechat_archive_message", "wechat_archive_media", "wechat_recall", "wechat_send_share", "wechat_group_info", "wechat_login"]
   },
   "toolMetadata": {
     "wechat_archive_threads": { "optional": true },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-wechat/agent-wechat",
-  "version": "1.0.0-beta.12",
+  "version": "1.0.0-beta.14",
   "type": "module",
   "files": [
     "dist",
@@ -11,7 +11,7 @@
     "esbuild": "^0.25.0",
     "openclaw": "2026.10.2",
     "typescript": "^5.4.5",
-    "@agent-wechat/shared": "1.0.0-beta.2"
+    "@agent-wechat/shared": "1.0.0-beta.3"
   },
   "openclaw": {
     "extensions": [