@soimy/dingtalk 3.6.9 → 3.6.11

package/dist/index.js

@@ -1,51 +1,24 @@
 // index.ts
-import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
+import {
+  defineChannelPluginEntry
+} from "openclaw/plugin-sdk/core";
 import { readStringParam as readStringParam2 } from "openclaw/plugin-sdk/param-readers";
 
 // src/secret-input.ts
-import { readFile } from "node:fs/promises";
+import {
+  hasConfiguredSecretInput as hasConfiguredOpenClawSecretInput,
+  resolveConfiguredSecretInputString
+} from "openclaw/plugin-sdk/secret-input-runtime";
 import { z } from "zod";
 
-// src/path-utils.ts
-import * as os from "node:os";
-import * as path from "node:path";
-var WINDOWS_ROOT_DIRECTORIES = /* @__PURE__ */ new Set([
-  "Users",
-  "Program Files",
-  "Program Files (x86)",
-  "ProgramData",
-  "Windows",
-  "Documents and Settings"
-]);
-function resolveRelativePath(input) {
-  const trimmed = input.trim();
-  if (!trimmed) {
-    return trimmed;
-  }
-  const segments = (value) => value.split(/[\\/]+/).filter(Boolean);
-  const pathSegments = segments(trimmed);
-  const firstSegment = pathSegments[0];
-  if (trimmed === "~") {
-    return path.resolve(os.homedir());
-  }
-  if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
-    return path.resolve(os.homedir(), ...segments(trimmed.slice(2)));
-  }
-  if (process.platform === "win32") {
-    if (/^[a-zA-Z]:[\\/]/.test(trimmed)) {
-      return path.win32.normalize(trimmed);
-    }
-    if (firstSegment && /^[a-zA-Z]:$/.test(firstSegment)) {
-      return path.win32.resolve(`${firstSegment}\\`, ...pathSegments.slice(1));
-    }
-    if (firstSegment && WINDOWS_ROOT_DIRECTORIES.has(firstSegment)) {
-      return path.win32.resolve("\\", ...pathSegments);
-    }
-  }
-  if (/^[\\/]/.test(trimmed)) {
-    return path.resolve(path.sep, ...pathSegments);
-  }
-  return path.resolve(process.cwd(), ...pathSegments);
+// src/runtime.ts
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+var runtimeStore = createPluginRuntimeStore("DingTalk runtime not initialized");
+function setDingTalkRuntime(next) {
+  runtimeStore.setRuntime(next);
+}
+function getDingTalkRuntime() {
+  return runtimeStore.getRuntime();
 }
 
 // src/secret-input.ts
@@ -62,16 +35,6 @@ function buildSecretInputFailure(value, reason) {
 function formatSecretInputResolutionFailure(failure) {
   return `${failure.source}:${failure.provider}:${failure.id} - ${failure.reason}`;
 }
-function buildSecretInputSchema() {
-  return z.union([
-    z.string(),
-    z.object({
-      source: z.enum(["env", "file"]),
-      provider: z.string().min(1).max(1024).regex(SECRET_INPUT_PROVIDER_PATTERN),
-      id: z.string().min(1).max(1024).regex(SECRET_INPUT_ID_PATTERN)
-    })
-  ]);
-}
 function isSecretInputRef(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -80,16 +43,7 @@ function isSecretInputRef(value) {
   return (ref.source === "env" || ref.source === "file") && typeof ref.provider === "string" && ref.provider.trim().length > 0 && SECRET_INPUT_PROVIDER_PATTERN.test(ref.provider) && typeof ref.id === "string" && ref.id.trim().length > 0 && SECRET_INPUT_ID_PATTERN.test(ref.id);
 }
 function hasConfiguredSecretInput(value) {
-  if (typeof value === "string") {
-    return value.trim().length > 0;
-  }
-  if (!isSecretInputRef(value)) {
-    return false;
-  }
-  if (value.source === "env") {
-    return Boolean(process.env[value.id]?.trim());
-  }
-  return true;
+  return hasConfiguredOpenClawSecretInput(value);
 }
 function normalizeSecretInputString(value) {
   if (typeof value === "string") {
@@ -119,7 +73,7 @@ function parseSecretInputString(value) {
     id: match[3]
   };
 }
-async function resolveSecretInputStringWithFailure(value, log) {
+async function resolveSecretInputStringWithFailure(value, log, hostConfig) {
   if (typeof value === "string") {
     const trimmed = value.trim();
     return { value: trimmed || void 0 };
@@ -127,32 +81,40 @@ async function resolveSecretInputStringWithFailure(value, log) {
   if (!isSecretInputRef(value)) {
     return {};
   }
-  if (value.source === "env") {
-    const envValue = process.env[value.id]?.trim();
-    if (envValue) {
-      return { value: envValue };
+  if (!hostConfig) {
+    try {
+      hostConfig = getDingTalkRuntime().config.current();
+    } catch {
+      hostConfig = {};
     }
-    const failure = buildSecretInputFailure(value, "environment variable is not set or is empty");
-    log?.warn?.("[DingTalk][SecretInput] Failed to resolve env secret", {
+  }
+  try {
+    const resolved = await resolveConfiguredSecretInputString({
+      config: hostConfig,
+      env: process.env,
+      value,
+      path: "channels.dingtalk.clientSecret",
+      unresolvedReasonStyle: "detailed"
+    });
+    if (resolved.value) {
+      return { value: resolved.value };
+    }
+    const failure = buildSecretInputFailure(
+      value,
+      resolved.unresolvedRefReason || "secret reference is unresolved"
+    );
+    log?.warn?.("[DingTalk][SecretInput] Failed to resolve secret", {
       provider: value.provider,
       id: value.id,
       error: failure.reason
     });
     return { failure };
-  }
-  try {
-    const filePath = resolveRelativePath(value.id);
-    const secret = (await readFile(filePath, "utf8")).trim();
-    if (secret) {
-      return { value: secret };
-    }
-    return { failure: buildSecretInputFailure(value, "file secret is empty") };
   } catch (error) {
     const failure = buildSecretInputFailure(
       value,
       error instanceof Error ? error.message : String(error)
     );
-    log?.warn?.("[DingTalk][SecretInput] Failed to read file secret", {
+    log?.warn?.("[DingTalk][SecretInput] Failed to resolve secret", {
       provider: value.provider,
       id: value.id,
       error: failure.reason
@@ -169,6 +131,48 @@ async function resolveDingTalkSecretConfig(config, log) {
   };
 }
 
+// src/path-utils.ts
+import * as os from "node:os";
+import * as path from "node:path";
+var WINDOWS_ROOT_DIRECTORIES = /* @__PURE__ */ new Set([
+  "Users",
+  "Program Files",
+  "Program Files (x86)",
+  "ProgramData",
+  "Windows",
+  "Documents and Settings"
+]);
+function resolveRelativePath(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  const segments = (value) => value.split(/[\\/]+/).filter(Boolean);
+  const pathSegments = segments(trimmed);
+  const firstSegment = pathSegments[0];
+  if (trimmed === "~") {
+    return path.resolve(os.homedir());
+  }
+  if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
+    return path.resolve(os.homedir(), ...segments(trimmed.slice(2)));
+  }
+  if (process.platform === "win32") {
+    if (/^[a-zA-Z]:[\\/]/.test(trimmed)) {
+      return path.win32.normalize(trimmed);
+    }
+    if (firstSegment && /^[a-zA-Z]:$/.test(firstSegment)) {
+      return path.win32.resolve(`${firstSegment}\\`, ...pathSegments.slice(1));
+    }
+    if (firstSegment && WINDOWS_ROOT_DIRECTORIES.has(firstSegment)) {
+      return path.win32.resolve("\\", ...pathSegments);
+    }
+  }
+  if (/^[\\/]/.test(trimmed)) {
+    return path.resolve(path.sep, ...pathSegments);
+  }
+  return path.resolve(process.cwd(), ...pathSegments);
+}
+
 // src/config.ts
 var DEFAULT_LEARNING_NOTE_TTL_MS = 6 * 60 * 60 * 1e3;
 function normalizeLearningConfig(config, options) {
@@ -1031,8 +1035,238 @@ async function updateCardVariables(outTrackId, params, token, config) {
 // src/inbound-handler.ts
 import fs6 from "node:fs";
 import * as path10 from "node:path";
+import { formatInboundEnvelope } from "openclaw/plugin-sdk/channel-inbound";
 import { isAbortRequestText, isBtwRequestText } from "openclaw/plugin-sdk/reply-runtime";
-import { parseInlineDirectives } from "openclaw/plugin-sdk/text-runtime";
+
+// src/messaging/inline-directives.ts
+import { findCodeRegions, isInsideCode } from "openclaw/plugin-sdk/text-chunking";
+var AUDIO_TAG_RE = /\[\[\s*audio_as_voice\s*\]\]/gi;
+var REPLY_TAG_RE = /\[\[\s*(?:reply_to_current|reply_to\s*:\s*([^\]\n]+))\s*\]\]/gi;
+var MAX_REPLY_DIRECTIVE_ID_LENGTH = 256;
+var BLOCK_SENTINEL_SEED = "\uE000";
+var INDENTED_CODE_LINE_RE = /(?:^|\n)((?: {4}|\t)[^\n]*)(?:\n(?: {4}|\t)[^\n]*)*/g;
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function resolveCodeRegions(text) {
+  const indentedRegions = [];
+  const indentRe = new RegExp(INDENTED_CODE_LINE_RE.source, "g");
+  let match;
+  while ((match = indentRe.exec(text)) !== null) {
+    const start = match.index + (match[0].charCodeAt(0) === 10 ? 1 : 0);
+    indentedRegions.push({ start, end: match.index + match[0].length });
+  }
+  const sdkRegions = findCodeRegions(text).filter(
+    (region) => (text[region.start] !== "`" || !isEscaped(text, region.start)) && !indentedRegions.some(
+      (indented) => region.start >= indented.start && region.start < indented.end
+    )
+  );
+  const knownRegions = mergeCodeRegions([...sdkRegions, ...indentedRegions]);
+  return mergeCodeRegions([...knownRegions, ...findDelimiterCodeRegions(text, knownRegions)]);
+}
+function isEscaped(text, offset) {
+  let slashes = 0;
+  for (let index = offset - 1; text[index] === "\\"; index--) {
+    slashes++;
+  }
+  return slashes % 2 === 1;
+}
+function isStrictlyInsideCode(offset, regions) {
+  return regions.some((region) => offset > region.start && offset < region.end);
+}
+function findDelimiterCodeRegions(text, knownRegions) {
+  const regions = [];
+  let match;
+  const fences = /^( {0,3})(`{3,}|~{3,})[^\n]*(?:\n|$)/gm;
+  let open;
+  while ((match = fences.exec(text)) !== null) {
+    const delimiter = match[2];
+    if (!open) {
+      const suffix = match[0].slice(match[1].length + delimiter.length).trim();
+      if (isStrictlyInsideCode(match.index, knownRegions) || delimiter[0] === "`" && suffix.includes("`")) {
+        continue;
+      }
+      open = { char: delimiter[0], length: delimiter.length, start: match.index };
+    } else if (delimiter[0] === open.char && delimiter.length >= open.length && match[0].slice(match[1].length + delimiter.length).trim() === "") {
+      regions.push({ start: open.start, end: fences.lastIndex });
+      open = void 0;
+    }
+  }
+  if (open) {
+    regions.push({ start: open.start, end: text.length });
+  }
+  const fencedRegions = [...regions];
+  const pendingTicks = /* @__PURE__ */ new Map();
+  const ticks = /`+/g;
+  while ((match = ticks.exec(text)) !== null) {
+    const length = match[0].length;
+    if (isEscaped(text, match.index) || isInsideCode(match.index, fencedRegions) || pendingTicks.get(length) === void 0 && isStrictlyInsideCode(match.index, knownRegions)) {
+      continue;
+    }
+    const start = pendingTicks.get(length);
+    if (start === void 0) {
+      pendingTicks.set(length, match.index);
+      continue;
+    }
+    regions.push({ start, end: ticks.lastIndex });
+    for (const [pendingLength, pendingStart] of pendingTicks) {
+      if (pendingStart >= start) {
+        pendingTicks.delete(pendingLength);
+      }
+    }
+  }
+  return regions;
+}
+function mergeCodeRegions(regions) {
+  if (regions.length <= 1) {
+    return regions;
+  }
+  const sorted = [...regions].toSorted((a, b) => a.start - b.start || a.end - b.end);
+  const merged = [];
+  for (const region of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && region.start <= last.end) {
+      last.end = Math.max(last.end, region.end);
+    } else {
+      merged.push({ start: region.start, end: region.end });
+    }
+  }
+  return merged;
+}
+function createBlockSentinel(text) {
+  let sentinel = BLOCK_SENTINEL_SEED;
+  while (text.includes(sentinel)) {
+    sentinel += BLOCK_SENTINEL_SEED;
+  }
+  return sentinel;
+}
+function normalizeDirectiveWhitespace(text, codeRegions = []) {
+  const blockSentinel = createBlockSentinel(text);
+  const blockPlaceholderRe = new RegExp(`${blockSentinel}(\\d+)${blockSentinel}`, "g");
+  const blocks = [];
+  let masked = "";
+  let cursor = 0;
+  for (const region of codeRegions) {
+    if (region.start < cursor) {
+      continue;
+    }
+    blocks.push(text.slice(region.start, region.end));
+    masked += `${text.slice(cursor, region.start)}${blockSentinel}${blocks.length - 1}${blockSentinel}`;
+    cursor = region.end;
+  }
+  masked += text.slice(cursor);
+  return masked.replace(/\r\n/g, "\n").replace(/([^\s])[ \t]{2,}([^\s])/g, "$1 $2").replace(/^\n+/, "").replace(/^[ \t](?=\S)/, "").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trimEnd().replace(blockPlaceholderRe, (_full, index) => blocks[Number(index)] ?? "");
+}
+function replacementPreservesWordBoundary(source, offset, length) {
+  const before = source[offset - 1];
+  const after = source[offset + length];
+  return before && after && !/\s/u.test(before) && !/\s/u.test(after) ? " " : "";
+}
+function stripUnsafeReplyDirectiveChars(value) {
+  const chars = [];
+  for (const ch of value) {
+    const code = ch.charCodeAt(0);
+    if (code >= 0 && code <= 31 || code === 127 || code >= 128 && code <= 159 || ch === "[" || ch === "]") {
+      continue;
+    }
+    chars.push(ch);
+  }
+  return chars.join("");
+}
+function sanitizeReplyDirectiveId(rawReplyToId) {
+  const trimmed = rawReplyToId?.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const sanitized = stripUnsafeReplyDirectiveChars(trimmed).trim();
+  if (!sanitized) {
+    return void 0;
+  }
+  const chars = Array.from(sanitized);
+  if (chars.length > MAX_REPLY_DIRECTIVE_ID_LENGTH) {
+    return chars.slice(0, MAX_REPLY_DIRECTIVE_ID_LENGTH).join("");
+  }
+  return sanitized;
+}
+function parseInlineDirectives(text, options = {}) {
+  const { currentMessageId, stripAudioTag = true, stripReplyTags = true } = options;
+  if (!text) {
+    return {
+      text: "",
+      audioAsVoice: false,
+      replyToCurrent: false,
+      hasAudioTag: false,
+      hasReplyTag: false
+    };
+  }
+  if (!text.includes("[[")) {
+    return {
+      text: normalizeDirectiveWhitespace(text, resolveCodeRegions(text)),
+      audioAsVoice: false,
+      replyToCurrent: false,
+      hasAudioTag: false,
+      hasReplyTag: false
+    };
+  }
+  const codeRegions = resolveCodeRegions(text);
+  let cleaned = text;
+  let audioAsVoice = false;
+  let hasAudioTag = false;
+  let hasReplyTag = false;
+  let sawCurrent = false;
+  let lastExplicitId;
+  cleaned = cleaned.replace(AUDIO_TAG_RE, (match, offset, source) => {
+    if (isInsideCode(offset, codeRegions)) {
+      return match;
+    }
+    audioAsVoice = true;
+    hasAudioTag = true;
+    return stripAudioTag ? replacementPreservesWordBoundary(source, offset, match.length) : match;
+  });
+  const codeRegionsAfterAudioStrip = resolveCodeRegions(cleaned);
+  cleaned = cleaned.replace(
+    REPLY_TAG_RE,
+    (match, idRaw, offset, source) => {
+      if (isInsideCode(offset, codeRegionsAfterAudioStrip)) {
+        return match;
+      }
+      hasReplyTag = true;
+      if (idRaw === void 0) {
+        sawCurrent = true;
+      } else {
+        const id = sanitizeReplyDirectiveId(idRaw);
+        if (id) {
+          lastExplicitId = id;
+        }
+      }
+      return stripReplyTags ? replacementPreservesWordBoundary(source, offset, match.length) : match;
+    }
+  );
+  if (!hasAudioTag && !hasReplyTag) {
+    return {
+      text,
+      audioAsVoice: false,
+      replyToCurrent: false,
+      hasAudioTag: false,
+      hasReplyTag: false
+    };
+  }
+  cleaned = normalizeDirectiveWhitespace(cleaned, resolveCodeRegions(cleaned));
+  const replyToId = lastExplicitId ?? (sawCurrent ? normalizeOptionalString(currentMessageId) : void 0);
+  return {
+    text: cleaned,
+    audioAsVoice,
+    replyToId,
+    replyToExplicitId: lastExplicitId,
+    replyToCurrent: sawCurrent,
+    hasAudioTag,
+    hasReplyTag
+  };
+}
 
 // src/access-control.ts
 function normalizeAllowFrom(list) {
@@ -1679,110 +1913,20 @@ var DINGTALK_ASK_USER_CARD_TEMPLATE = Object.freeze({
   templateId: BUILTIN_DINGTALK_ASK_USER_CARD_TEMPLATE_ID
 });
 
-// src/peer-id-registry.ts
-import { readFileSync, readdirSync as readdirSync2 } from "fs";
-import * as os3 from "os";
-import { join as join2 } from "path";
-
-// src/logger-context.ts
-var currentLogger;
-var loggerByAccountId = /* @__PURE__ */ new Map();
-function setCurrentLogger(log, accountId) {
-  currentLogger = log;
-  const normalizedAccountId = typeof accountId === "string" ? accountId.trim() : "";
-  if (!normalizedAccountId) {
-    return;
-  }
-  if (log) {
-    loggerByAccountId.set(normalizedAccountId, log);
-    return;
-  }
-  loggerByAccountId.delete(normalizedAccountId);
-}
-function getLogger(accountId) {
-  const normalizedAccountId = typeof accountId === "string" ? accountId.trim() : "";
-  if (normalizedAccountId) {
-    return loggerByAccountId.get(normalizedAccountId);
-  }
-  return currentLogger;
-}
-
 // src/peer-id-registry.ts
 var peerIdMap = /* @__PURE__ */ new Map();
-var preloaded = false;
 function registerPeerId(originalId) {
   if (!originalId) {
     return;
   }
   peerIdMap.set(originalId.toLowerCase(), originalId);
 }
-function maybeRegisterDingTalkGroupPeerId(value) {
-  if (typeof value === "string" && value.startsWith("cid")) {
-    registerPeerId(value);
-  }
-}
 function resolveOriginalPeerId(id) {
   if (!id) {
     return id;
   }
-  if (!preloaded) {
-    preloadPeerIdsFromSessions();
-  }
   return peerIdMap.get(id.toLowerCase()) || id;
 }
-function preloadPeerIdsFromSessions(homeDir) {
-  if (!homeDir && preloaded) {
-    return;
-  }
-  const home = homeDir || os3.homedir();
-  const agentsDir = join2(home, ".openclaw", "agents");
-  const log = getLogger();
-  let preloadCompleted = false;
-  try {
-    const agentDirs = readdirSync2(agentsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-    for (const agentName of agentDirs) {
-      const sessionsPath = join2(agentsDir, agentName, "sessions", "sessions.json");
-      try {
-        const raw = readFileSync(sessionsPath, "utf-8");
-        const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== "object") {
-          continue;
-        }
-        for (const session of Object.values(parsed)) {
-          if (!session || typeof session !== "object") {
-            continue;
-          }
-          const sessionRecord = session;
-          maybeRegisterDingTalkGroupPeerId(sessionRecord.lastTo);
-          const origin = sessionRecord.origin;
-          if (!origin || typeof origin !== "object") {
-            continue;
-          }
-          const originRecord = origin;
-          maybeRegisterDingTalkGroupPeerId(originRecord.from);
-          maybeRegisterDingTalkGroupPeerId(originRecord.to);
-        }
-      } catch (err) {
-        log?.debug?.(
-          `[DingTalk][PeerIdRegistry] Failed to parse preload sessions file ${sessionsPath}: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    preloadCompleted = true;
-  } catch (err) {
-    const errorCode = err?.code;
-    if (errorCode === "ENOENT") {
-      preloadCompleted = true;
-    } else {
-      log?.debug?.(
-        `[DingTalk][PeerIdRegistry] Failed to scan preload directory ${agentsDir}: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  if (!homeDir && preloadCompleted) {
-    preloaded = true;
-  }
-}
 
 // src/persistence-store.ts
 import * as fs2 from "node:fs";
@@ -3639,18 +3783,6 @@ function resolveConfiguredTaskModelMetadata(params) {
 
 // src/command/card-stop-command.ts
 import { resolveNativeCommandSessionTargets } from "openclaw/plugin-sdk/command-auth";
-
-// src/runtime.ts
-import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
-var runtimeStore = createPluginRuntimeStore("DingTalk runtime not initialized");
-function setDingTalkRuntime(next) {
-  runtimeStore.setRuntime(next);
-}
-function getDingTalkRuntime() {
-  return runtimeStore.getRuntime();
-}
-
-// src/command/card-stop-command.ts
 async function dispatchDingTalkCardStopCommand(params) {
   const rt = getDingTalkRuntime();
   const { sessionKey: commandSessionKey, commandTargetSessionKey } = resolveNativeCommandSessionTargets({
@@ -5161,9 +5293,32 @@ function pickQueueBusyAckPhrase(seed) {
 // src/send-service.ts
 import * as path6 from "node:path";
 
+// src/logger-context.ts
+var currentLogger;
+var loggerByAccountId = /* @__PURE__ */ new Map();
+function setCurrentLogger(log, accountId) {
+  currentLogger = log;
+  const normalizedAccountId = typeof accountId === "string" ? accountId.trim() : "";
+  if (!normalizedAccountId) {
+    return;
+  }
+  if (log) {
+    loggerByAccountId.set(normalizedAccountId, log);
+    return;
+  }
+  loggerByAccountId.delete(normalizedAccountId);
+}
+function getLogger(accountId) {
+  const normalizedAccountId = typeof accountId === "string" ? accountId.trim() : "";
+  if (normalizedAccountId) {
+    return loggerByAccountId.get(normalizedAccountId);
+  }
+  return currentLogger;
+}
+
 // src/media-utils.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import * as os4 from "node:os";
+import * as os3 from "node:os";
 import * as path5 from "node:path";
 import { promises as fsPromises } from "node:fs";
 import { lookup as dnsLookup } from "node:dns/promises";
@@ -5319,7 +5474,7 @@ async function prepareVoiceUploadPath(mediaPath, log) {
   if (DINGTALK_VOICE_UPLOAD_EXTENSIONS.has(ext)) {
     return { path: mediaPath };
   }
-  const outputPath = path5.join(os4.tmpdir(), `dingtalk_voice_${randomUUID3()}.ogg`);
+  const outputPath = path5.join(os3.tmpdir(), `dingtalk_voice_${randomUUID3()}.ogg`);
   await runFfmpeg([
     "-y",
     "-i",
@@ -5684,7 +5839,7 @@ async function prepareMediaInput(input, log, mediaUrlAllowlist) {
   const contentType = typeof response.headers?.["content-type"] === "string" ? response.headers["content-type"] : void 0;
   const urlPath = currentUrl.pathname;
   const ext = path5.extname(urlPath) || detectExtensionFromContentType(contentType) || ".bin";
-  const tempPath = path5.join(os4.tmpdir(), `dingtalk_${randomUUID3()}${ext}`);
+  const tempPath = path5.join(os3.tmpdir(), `dingtalk_${randomUUID3()}${ext}`);
   const buffer = Buffer.isBuffer(response.data) ? response.data : Buffer.from(response.data);
   await fsPromises.writeFile(tempPath, buffer);
   log?.debug?.(`[DingTalk] Downloaded remote media to temp file: ${tempPath}`);
@@ -12116,7 +12271,7 @@ ${attachmentExtractedText}` : inboundBody;
     }
     const groupMembers = !isDirect ? formatGroupMembers(storePath, groupId) : void 0;
     const fromLabel = isDirect ? `${senderName} (${senderId})` : `${groupName} - ${senderName}`;
-    const body = rt.channel.reply.formatInboundEnvelope({
+    const body = formatInboundEnvelope({
       channel: "DingTalk",
       from: fromLabel,
       timestamp: data.createAt,
@@ -13826,139 +13981,869 @@ function registerDingTalkAskUserQuestionTool(api) {
 }
 
 // src/channel.ts
-import { buildChannelConfigSchema } from "openclaw/plugin-sdk/core";
+import { buildJsonChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
 
-// src/config-schema.ts
-import { z as z2 } from "zod";
-var AckReactionSchema = z2.union([
-  z2.literal(""),
-  z2.enum(["off", "emoji", "kaomoji"]),
-  z2.string().min(1)
-]);
-var CardStreamingModeSchema = z2.enum(["off", "answer", "all"]);
-var ContextVisibilitySchema = z2.enum(["all", "allowlist", "allowlist_quote"]);
-var DingTalkAccountConfigShape = {
-  /** Account name (optional display name) */
-  name: z2.string().optional(),
-  /** Enable or disable this DingTalk channel/account without deleting saved credentials. */
-  enabled: z2.boolean().optional().default(true),
-  /** DingTalk App Key (Client ID) used to authenticate API and Stream connections. */
-  clientId: z2.string().optional(),
-  /** DingTalk App Secret (Client Secret) used to obtain DingTalk access tokens. */
-  clientSecret: buildSecretInputSchema().optional(),
-  /** Direct-message access policy: open, pairing, or allowlist. */
-  dmPolicy: z2.enum(["open", "pairing", "allowlist"]).optional().default("open"),
-  /** Group-message access policy: open, allowlist, or disabled. */
-  groupPolicy: z2.enum(["open", "allowlist", "disabled"]).optional().default("open"),
-  /** User IDs allowed when `dmPolicy` is `allowlist`. */
-  allowFrom: z2.array(z2.string()).optional(),
-  /** Sender IDs allowed when `groupPolicy` is `allowlist`. */
-  groupAllowFrom: z2.array(z2.string()).optional(),
-  /** Default disabled. Enabling `all` allows learned displayName lookup but may misroute on stale or duplicate names and is available to all callers until upstream exposes requester authz context. */
-  displayNameResolution: z2.enum(["disabled", "all"]).optional().default("disabled"),
-  /** Controls how much supplemental host context remains visible to the reply runtime. `allowlist_quote` is the safest advanced mode when only explicit quotes or replies should remain visible. */
-  contextVisibility: ContextVisibilitySchema.optional(),
-  /** Allowed remote media download hosts, IPs, or CIDRs for media fetches. */
-  mediaUrlAllowlist: z2.array(z2.string()).optional(),
-  /** Native acknowledgement reaction mode: off, emoji, kaomoji, or a custom compatibility string. */
-  ackReaction: AckReactionSchema.optional(),
-  /** Retention window in days for short-lived message context used by quoting and media recovery. */
-  journalTTLDays: z2.number().int().min(1).optional().default(DEFAULT_MESSAGE_CONTEXT_TTL_DAYS),
-  /** Enable verbose DingTalk channel debug logging. */
-  debug: z2.boolean().optional().default(false),
-  /** Default reply delivery mode: markdown or card. */
-  messageType: z2.enum(["markdown", "card"]).optional().default("markdown"),
-  /** Deprecated and ignored. AI card replies now always use the built-in DingTalk template contract. Keep only for backward-compatible config parsing. */
-  cardTemplateId: z2.string().optional(),
-  /** Deprecated and ignored. The built-in AI card contract owns the streaming field mapping. Keep only for backward-compatible config parsing. */
-  cardTemplateKey: z2.string().optional().default("content"),
-  /** Per-group overrides keyed by conversationId. Supports `*` as a wildcard fallback. */
-  groups: z2.record(
-    z2.string(),
-    z2.object({
-      /** Additional system prompt appended for this group. */
-      systemPrompt: z2.string().optional(),
-      /** Require an explicit @mention before the bot answers in this group. */
-      requireMention: z2.boolean().optional(),
-      /** Optional per-group sender allowlist for tighter access control than the channel default. */
-      groupAllowFrom: z2.array(z2.string()).optional()
-    })
-  ).optional(),
-  /** Connection robustness configuration */
-  /** Maximum connection attempts in a single reconnect cycle before backing off or giving up. */
-  maxConnectionAttempts: z2.number().int().min(1).optional().default(10),
-  /** Initial reconnect backoff delay in milliseconds. */
-  initialReconnectDelay: z2.number().int().min(100).optional().default(1e3),
-  /** Upper bound for reconnect backoff delay in milliseconds. */
-  maxReconnectDelay: z2.number().int().min(1e3).optional().default(6e4),
-  /** Randomization factor added to reconnect backoff to avoid synchronized reconnect storms. */
-  reconnectJitter: z2.number().min(0).max(1).optional().default(0.3),
-  /** Maximum reconnect cycles before the channel stops retrying and waits for the next lifecycle restart. */
-  maxReconnectCycles: z2.number().int().min(1).optional().default(10),
-  /** Time limit in milliseconds for one reconnect cycle before starting a fresh cycle. */
-  reconnectDeadlineMs: z2.number().int().min(5e3).optional().default(5e4),
-  /** Enable the plugin connection manager. Disable only when you intentionally rely on DWClient native keepAlive plus autoReconnect behavior. */
-  useConnectionManager: z2.boolean().optional().default(true),
-  /** Maximum inbound media size in MB accepted by the plugin. When omitted, the runtime default is used. */
-  mediaMaxMb: z2.number().int().min(1).optional(),
-  /** Enable the underlying Stream client heartbeat. When omitted, runtime derives a default from `useConnectionManager`. */
-  keepAlive: z2.boolean().optional(),
-  /** Bypass global or system HTTP(S) proxy settings for DingTalk send, upload, and card APIs. */
-  bypassProxyForSend: z2.boolean().optional().default(false),
-  /** Controls the proactive-send permission reminder shown when a conversation has not granted send rights yet. */
-  proactivePermissionHint: z2.object({
-    /** Show the proactive-send permission hint when the runtime detects missing DingTalk proactive permission. */
-    enabled: z2.boolean().optional().default(true),
-    /** Minimum cooldown in hours before the same proactive permission hint can be shown again. */
-    cooldownHours: z2.number().int().min(1).max(24 * 30).optional().default(24)
-  }).optional().default({ enabled: true, cooldownHours: 24 }),
-  /** Deprecated compatibility flag. When true and `cardStreamingMode` is unset, runtime resolves to `cardStreamingMode: "all"`. Do not use in new configs. */
-  cardRealTimeStream: z2.boolean().optional(),
-  /** Card streaming mode:
-   *  - off: disable incremental streaming
-   *  - answer: stream answer text
-   *  - all: stream answer + reasoning or thinking text */
-  cardStreamingMode: CardStreamingModeSchema.optional(),
-  /** Throttle interval in milliseconds between AI card streaming updates. */
-  cardStreamInterval: z2.number().int().min(200).optional().default(1e3),
-  /** Cooldown window in milliseconds after AI card trigger errors. Replies fall back to non-card delivery during this period. */
-  aicardDegradeMs: z2.number().int().min(6e4).optional().default(30 * 60 * 1e3),
-  /** Enable the local feedback-learning loop for notes, reflections, and command-assisted learning. */
-  learningEnabled: z2.boolean().optional(),
-  /** Automatically apply generated learning output into session notes or global rules when available. */
-  learningAutoApply: z2.boolean().optional(),
-  /** Retention window in milliseconds for temporary learning notes. */
-  learningNoteTtlMs: z2.number().int().min(6e4).optional(),
-  /** Convert markdown tables to plain text before sending when you want more consistent DingTalk rendering. */
-  convertMarkdownTables: z2.boolean().optional().default(true),
-  /** @mention the sender after card finalization in group chats.
-   *  Set to a non-empty string (e.g. "✅ 回复完成") to enable — the value is used as the message text.
-   *  Leave empty or omit to disable. */
-  cardAtSender: z2.string().optional(),
-  /** Status line visibility toggles for the AI card footer. */
-  cardStatusLine: z2.object({
-    /** Show model name. */
-    model: z2.boolean().optional().default(true),
-    /** Show thinking effort level. */
-    effort: z2.boolean().optional().default(true),
-    /** Show agent display name. */
-    agent: z2.boolean().optional().default(true),
-    /** Show task elapsed time. */
-    taskTime: z2.boolean().optional().default(false),
-    /** Show token usage summary (input/output/cache). */
-    tokens: z2.boolean().optional().default(false),
-    /** Show DingTalk API call count. */
-    dapiUsage: z2.boolean().optional().default(false)
-  }).optional().default({ model: true, effort: true, agent: true, taskTime: false, tokens: false, dapiUsage: false })
+// openclaw.plugin.json
+var openclaw_plugin_default = {
+  id: "dingtalk",
+  name: "DingTalk",
+  channels: ["dingtalk"],
+  contracts: {
+    tools: ["dingtalk_ask_user_question"]
+  },
+  configSchema: {
+    type: "object",
+    additionalProperties: true,
+    properties: {}
+  },
+  channelConfigs: {
+    dingtalk: {
+      label: "DingTalk",
+      description: "\u9489\u9489\u4F01\u4E1A\u5185\u90E8\u673A\u5668\u4EBA\uFF0C\u4F7F\u7528 Stream \u6A21\u5F0F\uFF0C\u65E0\u9700\u516C\u7F51 IP\u3002",
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          name: {
+            type: "string",
+            description: "Optional display name shown for this DingTalk channel or default account."
+          },
+          enabled: {
+            type: "boolean",
+            default: true,
+            description: "Enable or disable this DingTalk channel configuration without deleting saved credentials."
+          },
+          agentId: {
+            type: "integer",
+            description: "Legacy compatibility field from older setup flows. The current Stream-mode runtime no longer reads this value, so new configs should omit it."
+          },
+          corpId: {
+            type: "string",
+            description: "Legacy compatibility field from older enterprise app setup flows. The current Stream-mode runtime no longer needs or reads this value."
+          },
+          clientId: {
+            type: "string",
+            description: "DingTalk App Key (Client ID) used to authenticate API and Stream connections."
+          },
+          clientSecret: {
+            anyOf: [
+              { type: "string" },
+              {
+                type: "object",
+                additionalProperties: false,
+                required: ["source", "provider", "id"],
+                properties: {
+                  source: { type: "string", enum: ["env", "file"] },
+                  provider: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 1024,
+                    pattern: "^[^:>]+$"
+                  },
+                  id: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 1024,
+                    pattern: "^[^>]+$"
+                  }
+                }
+              }
+            ],
+            description: "DingTalk App Secret (Client Secret) used to obtain DingTalk access tokens. Supports env/file SecretInput references resolved by configured OpenClaw secret providers."
+          },
+          dmPolicy: {
+            type: "string",
+            enum: ["open", "pairing", "allowlist"],
+            default: "open",
+            description: "Direct-message access policy. open allows any DM, pairing requires host pairing, and allowlist only permits IDs listed in allowFrom."
+          },
+          groupPolicy: {
+            type: "string",
+            enum: ["open", "allowlist", "disabled"],
+            default: "open",
+            description: "Group-message access policy. open allows all groups, allowlist restricts by groupAllowFrom, and disabled blocks group handling."
+          },
+          allowFrom: {
+            type: "array",
+            items: { type: "string" },
+            description: "User IDs allowed when dmPolicy is allowlist. Accepts DingTalk IDs or host-normalized IDs."
+          },
+          groupAllowFrom: {
+            type: "array",
+            items: { type: "string" },
+            description: "Sender IDs allowed when groupPolicy is allowlist. Leave empty unless you want per-sender restrictions in groups."
+          },
+          displayNameResolution: {
+            type: "string",
+            enum: ["disabled", "all"],
+            default: "disabled",
+            description: "Whether learned display names can be used to resolve DingTalk users or groups. Keep disabled unless you explicitly accept stale or ambiguous-name routing risk."
+          },
+          contextVisibility: {
+            type: "string",
+            enum: ["all", "allowlist", "allowlist_quote"],
+            description: "Host-level context filtering before prompts are sent to the runtime. allowlist_quote is the safest advanced mode when only explicit quote or reply context should remain visible."
+          },
+          mediaUrlAllowlist: {
+            type: "array",
+            items: { type: "string" },
+            description: "Allowed download hosts, IPs, or CIDRs for remote media fetches. Use this for internal file servers or custom CDN domains."
+          },
+          ackReaction: {
+            anyOf: [
+              { type: "string", const: "" },
+              { type: "string", enum: ["off", "emoji", "kaomoji"] },
+              { type: "string", minLength: 1 }
+            ],
+            description: "Acknowledgement reaction mode. Supports off, emoji, kaomoji, or a custom compatibility string."
+          },
+          journalTTLDays: {
+            type: "integer",
+            minimum: 1,
+            default: 7,
+            description: "Retention window in days for short-lived message context used by quoting, media recovery, and related reply context features."
+          },
+          debug: {
+            type: "boolean",
+            default: false,
+            description: "Enable verbose DingTalk channel debug logging."
+          },
+          messageType: {
+            type: "string",
+            enum: ["markdown", "card"],
+            default: "markdown",
+            description: "Default reply delivery mode. markdown uses standard messages; card uses DingTalk AI cards when available."
+          },
+          cardTemplateId: {
+            type: "string",
+            description: "Deprecated and ignored. AI card replies now always use the built-in DingTalk template contract; keep only for compatibility with old configs."
+          },
+          cardTemplateKey: {
+            type: "string",
+            default: "content",
+            description: "Deprecated and ignored. The built-in AI card contract owns the streaming field mapping; keep only for compatibility with old configs."
+          },
+          groups: {
+            type: "object",
+            description: 'Per-group overrides keyed by conversationId. Supports "*" as a wildcard fallback.',
+            additionalProperties: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                systemPrompt: {
+                  type: "string",
+                  description: "Additional system prompt appended for this group."
+                },
+                requireMention: {
+                  type: "boolean",
+                  description: "Require an explicit @mention before the bot answers in this group."
+                },
+                groupAllowFrom: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "Per-group sender allowlist used when you want tighter access control than the channel default."
+                }
+              }
+            }
+          },
+          maxConnectionAttempts: {
+            type: "integer",
+            minimum: 1,
+            default: 10,
+            description: "Maximum connection attempts in a single reconnect cycle before backing off or giving up."
+          },
+          initialReconnectDelay: {
+            type: "integer",
+            minimum: 100,
+            default: 1e3,
+            description: "Initial reconnect backoff delay in milliseconds."
+          },
+          maxReconnectDelay: {
+            type: "integer",
+            minimum: 1e3,
+            default: 6e4,
+            description: "Upper bound for reconnect backoff delay in milliseconds."
+          },
+          reconnectJitter: {
+            type: "number",
+            minimum: 0,
+            maximum: 1,
+            default: 0.3,
+            description: "Randomization factor added to reconnect backoff to avoid synchronized reconnect storms."
+          },
+          maxReconnectCycles: {
+            type: "integer",
+            minimum: 1,
+            default: 10,
+            description: "Maximum reconnect cycles before the channel stops retrying and waits for the next lifecycle restart."
+          },
+          reconnectDeadlineMs: {
+            type: "integer",
+            minimum: 5e3,
+            default: 5e4,
+            description: "Time limit in milliseconds for one reconnect cycle before starting a fresh cycle."
+          },
+          useConnectionManager: {
+            type: "boolean",
+            default: true,
+            description: "Enable the plugin connection manager. Disable only when you intentionally rely on the DingTalk client keepAlive and autoReconnect behavior."
+          },
+          mediaMaxMb: {
+            type: "integer",
+            minimum: 1,
+            description: "Maximum inbound media size in MB accepted by the plugin. When omitted, the runtime default is used."
+          },
+          keepAlive: {
+            type: "boolean",
+            description: "Enable the underlying Stream client heartbeat. When omitted, runtime derives a default from useConnectionManager."
+          },
+          bypassProxyForSend: {
+            type: "boolean",
+            default: false,
+            description: "Bypass global or system HTTP(S) proxy settings for DingTalk send, upload, and card APIs."
+          },
+          proactivePermissionHint: {
+            type: "object",
+            description: "Controls the proactive-send permission reminder shown when a conversation has not granted send rights yet.",
+            additionalProperties: false,
+            properties: {
+              enabled: {
+                type: "boolean",
+                default: true,
+                description: "Show the proactive-send permission hint when the runtime detects missing DingTalk proactive permission."
+              },
+              cooldownHours: {
+                type: "integer",
+                minimum: 1,
+                maximum: 720,
+                default: 24,
+                description: "Minimum cooldown in hours before the same proactive permission hint can be shown again."
+              }
+            }
+          },
+          cardRealTimeStream: {
+            type: "boolean",
+            default: false,
+            description: 'Deprecated compatibility flag. If true and cardStreamingMode is unset, runtime falls back to cardStreamingMode="all". Do not use in new configs.'
+          },
+          cardStreamingMode: {
+            type: "string",
+            enum: ["off", "answer", "all"],
+            description: "AI card incremental streaming mode. off disables streaming, answer streams answer text only, and all streams answer plus reasoning or thinking text."
+          },
+          cardStreamInterval: {
+            type: "integer",
+            minimum: 200,
+            default: 1e3,
+            description: "Throttle interval in milliseconds between AI card streaming updates."
+          },
+          aicardDegradeMs: {
+            type: "integer",
+            minimum: 6e4,
+            default: 18e5,
+            description: "Cooldown window in milliseconds after AI card trigger errors. During this window replies fall back to non-card delivery."
+          },
+          learningEnabled: {
+            type: "boolean",
+            description: "Enable the local feedback-learning loop for notes, reflections, and command-assisted learning."
+          },
+          learningAutoApply: {
+            type: "boolean",
+            description: "Automatically apply generated learning output into session notes or global rules when available."
+          },
+          learningNoteTtlMs: {
+            type: "integer",
+            minimum: 6e4,
+            description: "Retention window in milliseconds for temporary learning notes."
+          },
+          convertMarkdownTables: {
+            type: "boolean",
+            default: true,
+            description: "Convert markdown tables to plain text before sending when you want more consistent DingTalk rendering."
+          },
+          cardAtSender: {
+            type: "string",
+            description: "Send a follow-up @mention text after card finalization in group chats. Any non-empty string becomes the message body."
+          },
+          cardStatusLine: {
+            type: "object",
+            description: "Status line visibility toggles for the AI card footer.",
+            additionalProperties: false,
+            default: { model: true, effort: true, agent: true, taskTime: false, tokens: false, dapiUsage: false },
+            properties: {
+              model: {
+                type: "boolean",
+                default: true,
+                description: "Show model name in AI card status line footer."
+              },
+              effort: {
+                type: "boolean",
+                default: true,
+                description: "Show thinking effort level in AI card status line footer."
+              },
+              agent: {
+                type: "boolean",
+                default: true,
+                description: "Show agent display name in AI card status line footer."
+              },
+              taskTime: {
+                type: "boolean",
+                default: false,
+                description: "Show task elapsed time in AI card status line footer."
+              },
+              tokens: {
+                type: "boolean",
+                default: false,
+                description: "Show token usage summary (input/output/cache) in AI card status line footer."
+              },
+              dapiUsage: {
+                type: "boolean",
+                default: false,
+                description: "Show DingTalk API call count in AI card status line footer."
+              }
+            }
+          },
+          showThinkingStream: {
+            type: "boolean",
+            description: "Legacy compatibility field from older card streaming behavior. It is not used by the current runtime and new configs should omit it."
+          },
+          asyncMode: {
+            type: "boolean",
+            description: "Legacy compatibility field from older host or runtime integrations. It is not used by the current runtime and new configs should omit it."
+          },
+          accounts: {
+            type: "object",
+            description: "Named multi-account DingTalk configurations. Each account can override most top-level settings and inherits unspecified values from the top level.",
+            additionalProperties: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                name: {
+                  type: "string",
+                  description: "Optional display name shown for this named DingTalk account."
+                },
+                enabled: {
+                  type: "boolean",
+                  default: true,
+                  description: "Enable or disable this DingTalk account without deleting saved credentials."
+                },
+                clientId: {
+                  type: "string",
+                  description: "DingTalk App Key (Client ID) used to authenticate API and Stream connections."
+                },
+                clientSecret: {
+                  anyOf: [
+                    { type: "string" },
+                    {
+                      type: "object",
+                      additionalProperties: false,
+                      required: ["source", "provider", "id"],
+                      properties: {
+                        source: { type: "string", enum: ["env", "file"] },
+                        provider: {
+                          type: "string",
+                          minLength: 1,
+                          maxLength: 1024,
+                          pattern: "^[^:>]+$"
+                        },
+                        id: {
+                          type: "string",
+                          minLength: 1,
+                          maxLength: 1024,
+                          pattern: "^[^>]+$"
+                        }
+                      }
+                    }
+                  ],
+                  description: "DingTalk App Secret (Client Secret) used to obtain DingTalk access tokens. Supports env/file SecretInput references resolved by configured OpenClaw secret providers."
+                },
+                dmPolicy: {
+                  type: "string",
+                  enum: ["open", "pairing", "allowlist"],
+                  default: "open",
+                  description: "Direct-message access policy. open allows any DM, pairing requires host pairing, and allowlist only permits IDs listed in allowFrom."
+                },
+                groupPolicy: {
+                  type: "string",
+                  enum: ["open", "allowlist", "disabled"],
+                  default: "open",
+                  description: "Group-message access policy. open allows all groups, allowlist restricts by groupAllowFrom, and disabled blocks group handling."
+                },
+                allowFrom: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "User IDs allowed when dmPolicy is allowlist. Accepts DingTalk IDs or host-normalized IDs."
+                },
+                groupAllowFrom: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "Sender IDs allowed when groupPolicy is allowlist. Leave empty unless you want per-sender restrictions in groups."
+                },
+                displayNameResolution: {
+                  type: "string",
+                  enum: ["disabled", "all"],
+                  default: "disabled",
+                  description: "Whether learned display names can be used to resolve DingTalk users or groups. Keep disabled unless you explicitly accept stale or ambiguous-name routing risk."
+                },
+                contextVisibility: {
+                  type: "string",
+                  enum: ["all", "allowlist", "allowlist_quote"],
+                  description: "Host-level context filtering before prompts are sent to the runtime. allowlist_quote is the safest advanced mode when only explicit quote or reply context should remain visible."
+                },
+                mediaUrlAllowlist: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "Allowed download hosts, IPs, or CIDRs for remote media fetches. Use this for internal file servers or custom CDN domains."
+                },
+                ackReaction: {
+                  anyOf: [
+                    { type: "string", const: "" },
+                    { type: "string", enum: ["off", "emoji", "kaomoji"] },
+                    { type: "string", minLength: 1 }
+                  ],
+                  description: "Acknowledgement reaction mode. Supports off, emoji, kaomoji, or a custom compatibility string."
+                },
+                journalTTLDays: {
+                  type: "integer",
+                  minimum: 1,
+                  default: 7,
+                  description: "Retention window in days for short-lived message context used by quoting, media recovery, and related reply context features."
+                },
+                debug: {
+                  type: "boolean",
+                  default: false,
+                  description: "Enable verbose DingTalk channel debug logging."
+                },
+                messageType: {
+                  type: "string",
+                  enum: ["markdown", "card"],
+                  default: "markdown",
+                  description: "Default reply delivery mode. markdown uses standard messages; card uses DingTalk AI cards when available."
+                },
+                cardTemplateId: {
+                  type: "string",
+                  description: "Deprecated and ignored. AI card replies now always use the built-in DingTalk template contract; keep only for compatibility with old configs."
+                },
+                cardTemplateKey: {
+                  type: "string",
+                  default: "content",
+                  description: "Deprecated and ignored. The built-in AI card contract owns the streaming field mapping; keep only for compatibility with old configs."
+                },
+                groups: {
+                  type: "object",
+                  description: 'Per-group overrides keyed by conversationId. Supports "*" as a wildcard fallback.',
+                  additionalProperties: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                      systemPrompt: {
+                        type: "string",
+                        description: "Additional system prompt appended for this group."
+                      },
+                      requireMention: {
+                        type: "boolean",
+                        description: "Require an explicit @mention before the bot answers in this group."
+                      },
+                      groupAllowFrom: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Per-group sender allowlist used when you want tighter access control than the channel default."
+                      }
+                    }
+                  }
+                },
+                maxConnectionAttempts: {
+                  type: "integer",
+                  minimum: 1,
+                  default: 10,
+                  description: "Maximum connection attempts in a single reconnect cycle before backing off or giving up."
+                },
+                initialReconnectDelay: {
+                  type: "integer",
+                  minimum: 100,
+                  default: 1e3,
+                  description: "Initial reconnect backoff delay in milliseconds."
+                },
+                maxReconnectDelay: {
+                  type: "integer",
+                  minimum: 1e3,
+                  default: 6e4,
+                  description: "Upper bound for reconnect backoff delay in milliseconds."
+                },
+                reconnectJitter: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 1,
+                  default: 0.3,
+                  description: "Randomization factor added to reconnect backoff to avoid synchronized reconnect storms."
+                },
+                maxReconnectCycles: {
+                  type: "integer",
+                  minimum: 1,
+                  default: 10,
+                  description: "Maximum reconnect cycles before the channel stops retrying and waits for the next lifecycle restart."
+                },
+                reconnectDeadlineMs: {
+                  type: "integer",
+                  minimum: 5e3,
+                  default: 5e4,
+                  description: "Time limit in milliseconds for one reconnect cycle before starting a fresh cycle."
+                },
+                useConnectionManager: {
+                  type: "boolean",
+                  default: true,
+                  description: "Enable the plugin connection manager. Disable only when you intentionally rely on the DingTalk client keepAlive and autoReconnect behavior."
+                },
+                mediaMaxMb: {
+                  type: "integer",
+                  minimum: 1,
+                  description: "Maximum inbound media size in MB accepted by the plugin. When omitted, the runtime default is used."
+                },
+                keepAlive: {
+                  type: "boolean",
+                  description: "Enable the underlying Stream client heartbeat. When omitted, runtime derives a default from useConnectionManager."
+                },
+                bypassProxyForSend: {
+                  type: "boolean",
+                  default: false,
+                  description: "Bypass global or system HTTP(S) proxy settings for DingTalk send, upload, and card APIs."
+                },
+                proactivePermissionHint: {
+                  type: "object",
+                  description: "Controls the proactive-send permission reminder shown when a conversation has not granted send rights yet.",
+                  additionalProperties: false,
+                  properties: {
+                    enabled: {
+                      type: "boolean",
+                      default: true,
+                      description: "Show the proactive-send permission hint when the runtime detects missing DingTalk proactive permission."
+                    },
+                    cooldownHours: {
+                      type: "integer",
+                      minimum: 1,
+                      maximum: 720,
+                      default: 24,
+                      description: "Minimum cooldown in hours before the same proactive permission hint can be shown again."
+                    }
+                  }
+                },
+                cardRealTimeStream: {
+                  type: "boolean",
+                  default: false,
+                  description: 'Deprecated compatibility flag. If true and cardStreamingMode is unset, runtime falls back to cardStreamingMode="all". Do not use in new configs.'
+                },
+                cardStreamingMode: {
+                  type: "string",
+                  enum: ["off", "answer", "all"],
+                  description: "AI card incremental streaming mode. off disables streaming, answer streams answer text only, and all streams answer plus reasoning or thinking text."
+                },
+                cardStreamInterval: {
+                  type: "integer",
+                  minimum: 200,
+                  default: 1e3,
+                  description: "Throttle interval in milliseconds between AI card streaming updates."
+                },
+                aicardDegradeMs: {
+                  type: "integer",
+                  minimum: 6e4,
+                  default: 18e5,
+                  description: "Cooldown window in milliseconds after AI card trigger errors. During this window replies fall back to non-card delivery."
+                },
+                learningEnabled: {
+                  type: "boolean",
+                  description: "Enable the local feedback-learning loop for notes, reflections, and command-assisted learning."
+                },
+                learningAutoApply: {
+                  type: "boolean",
+                  description: "Automatically apply generated learning output into session notes or global rules when available."
+                },
+                learningNoteTtlMs: {
+                  type: "integer",
+                  minimum: 6e4,
+                  description: "Retention window in milliseconds for temporary learning notes."
+                },
+                convertMarkdownTables: {
+                  type: "boolean",
+                  default: true,
+                  description: "Convert markdown tables to plain text before sending when you want more consistent DingTalk rendering."
+                },
+                cardAtSender: {
+                  type: "string",
+                  description: "Send a follow-up @mention text after card finalization in group chats. Any non-empty string becomes the message body."
+                },
+                cardStatusLine: {
+                  type: "object",
+                  description: "Status line visibility toggles for the AI card footer.",
+                  additionalProperties: false,
+                  default: { model: true, effort: true, agent: true, taskTime: false, tokens: false, dapiUsage: false },
+                  properties: {
+                    model: {
+                      type: "boolean",
+                      default: true,
+                      description: "Show model name in AI card status line footer."
+                    },
+                    effort: {
+                      type: "boolean",
+                      default: true,
+                      description: "Show thinking effort level in AI card status line footer."
+                    },
+                    agent: {
+                      type: "boolean",
+                      default: true,
+                      description: "Show agent display name in AI card status line footer."
+                    },
+                    taskTime: {
+                      type: "boolean",
+                      default: false,
+                      description: "Show task elapsed time in AI card status line footer."
+                    },
+                    tokens: {
+                      type: "boolean",
+                      default: false,
+                      description: "Show token usage summary (input/output/cache) in AI card status line footer."
+                    },
+                    dapiUsage: {
+                      type: "boolean",
+                      default: false,
+                      description: "Show DingTalk API call count in AI card status line footer."
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      uiHints: {
+        "": {
+          label: "DingTalk",
+          help: "DingTalk Stream-mode channel configuration including auth, delivery, targeting, and AI Card behavior."
+        },
+        name: {
+          label: "Display Name",
+          help: "Optional display name for the default DingTalk account shown in host configuration surfaces."
+        },
+        enabled: {
+          label: "Enabled",
+          help: "Turn the DingTalk channel on or off without deleting the saved configuration."
+        },
+        agentId: {
+          label: "Legacy Agent ID",
+          help: "Deprecated compatibility field from older setup flows. The current runtime ignores it, so leave it empty in new configs."
+        },
+        corpId: {
+          label: "Legacy Corp ID",
+          help: "Deprecated compatibility field from older enterprise app setup flows. Stream mode no longer needs or reads it."
+        },
+        clientId: {
+          label: "DingTalk Client ID",
+          help: "App Key used to authenticate DingTalk API requests."
+        },
+        clientSecret: {
+          label: "DingTalk Client Secret",
+          help: "App Secret used to obtain DingTalk access tokens. SecretInput references are resolved by configured OpenClaw secret providers.",
+          sensitive: true
+        },
+        dmPolicy: {
+          label: "Direct Message Policy",
+          help: "Choose who can talk to the bot in direct messages: open, host pairing only, or explicit allowlist."
+        },
+        groupPolicy: {
+          label: "Group Message Policy",
+          help: "Choose whether group messages are open to all groups, restricted by allowlist, or completely disabled."
+        },
+        allowFrom: {
+          label: "DM Allowlist",
+          help: "User IDs allowed when direct message policy is set to allowlist."
+        },
+        groupAllowFrom: {
+          label: "Group Sender Allowlist",
+          help: "Sender IDs allowed when group policy is allowlist or when you want tighter group sender restrictions."
+        },
+        messageType: {
+          label: "Reply Message Type",
+          help: "Choose markdown for standard replies or card for AI Card delivery."
+        },
+        ackReaction: {
+          label: "Ack Reaction",
+          help: "Native acknowledgement reaction mode. Supports preset values or a custom string for backward compatibility."
+        },
+        displayNameResolution: {
+          label: "Display Name Resolution",
+          help: "Keep disabled unless you explicitly want learned display-name targeting for all callers."
+        },
+        contextVisibility: {
+          label: "Context Visibility",
+          help: "Host-level context filtering. allowlist_quote is the safest advanced mode when you only want explicit quote/reply context."
+        },
+        mediaUrlAllowlist: {
+          label: "Media URL Allowlist",
+          help: "Allow remote media downloads only from the specified hosts, IPs, or CIDR ranges."
+        },
+        journalTTLDays: {
+          label: "Message Context TTL (days)",
+          help: "Retention period for short-lived quoted message and media recovery context."
+        },
+        debug: {
+          label: "Debug Logging",
+          help: "Enable verbose DingTalk channel debug logs for diagnostics."
+        },
+        cardTemplateId: {
+          label: "AI Card Template ID",
+          help: "Deprecated and ignored. AI card replies now always use the built-in DingTalk template contract."
+        },
+        cardTemplateKey: {
+          label: "AI Card Template Field Key",
+          help: "Deprecated and ignored. The built-in AI card contract owns the streaming field mapping."
+        },
+        groups: {
+          label: "Per-Group Overrides",
+          help: "Configure conversationId-specific overrides, or use * as a wildcard fallback."
+        },
+        "groups.systemPrompt": {
+          label: "Group System Prompt",
+          help: "Extra system prompt appended only for the selected group."
+        },
+        "groups.requireMention": {
+          label: "Require Mention",
+          help: "Require an explicit @mention before the bot answers in that group."
+        },
+        "groups.groupAllowFrom": {
+          label: "Per-Group Sender Allowlist",
+          help: "Optional sender allowlist that overrides or tightens the channel-level group access rule."
+        },
+        maxConnectionAttempts: {
+          label: "Max Connection Attempts",
+          help: "How many connection attempts are allowed within a reconnect cycle before the cycle backs off or ends."
+        },
+        initialReconnectDelay: {
+          label: "Initial Reconnect Delay",
+          help: "Initial reconnect backoff delay in milliseconds."
+        },
+        maxReconnectDelay: {
+          label: "Max Reconnect Delay",
+          help: "Upper bound for reconnect backoff delay in milliseconds."
+        },
+        reconnectJitter: {
+          label: "Reconnect Jitter",
+          help: "Randomization factor added to reconnect backoff to reduce synchronized reconnect storms."
+        },
+        maxReconnectCycles: {
+          label: "Max Reconnect Cycles",
+          help: "Maximum reconnect cycles before the channel stops retrying and waits for a later restart."
+        },
+        reconnectDeadlineMs: {
+          label: "Reconnect Cycle Deadline",
+          help: "Time limit in milliseconds for one reconnect cycle before starting a fresh cycle."
+        },
+        useConnectionManager: {
+          label: "Use Connection Manager",
+          help: "Recommended default. Disable only when you intentionally rely on the DingTalk client keepAlive and autoReconnect behavior."
+        },
+        mediaMaxMb: {
+          label: "Max Media Size (MB)",
+          help: "Maximum inbound media size accepted by the plugin. Leave empty to use the runtime default."
+        },
+        keepAlive: {
+          label: "Stream KeepAlive",
+          help: "Optional explicit heartbeat toggle for the underlying Stream client."
+        },
+        bypassProxyForSend: {
+          label: "Bypass Proxy For Send",
+          help: "Skip global or system HTTP(S) proxy settings for DingTalk send, upload, and card APIs."
+        },
+        cardRealTimeStream: {
+          label: "Legacy Real-Time Card Stream",
+          help: "Deprecated compatibility flag. When true and cardStreamingMode is unset, runtime falls back to all-streaming. Do not use in new configs."
+        },
+        cardStreamingMode: {
+          label: "Card Streaming Mode",
+          help: "Choose off, answer, or all. answer streams only answer text, while all streams answer plus reasoning or thinking text."
+        },
+        cardStreamInterval: {
+          label: "Card Stream Interval (ms)",
+          help: "Throttle interval in milliseconds between AI card incremental updates."
+        },
+        aicardDegradeMs: {
+          label: "AI Card Degrade Window (ms)",
+          help: "Cooldown window after AI card trigger errors. Replies fall back to non-card delivery during this period."
+        },
+        learningEnabled: {
+          label: "Learning Enabled",
+          help: "Enable the local feedback-learning loop for notes, reflections, and learning commands."
+        },
+        learningAutoApply: {
+          label: "Learning Auto Apply",
+          help: "Automatically apply generated learning output into session notes or global rules when available."
+        },
+        learningNoteTtlMs: {
+          label: "Learning Note TTL (ms)",
+          help: "Retention period for temporary learning notes."
+        },
+        convertMarkdownTables: {
+          label: "Convert Markdown Tables",
+          help: "Flatten markdown tables into plain text before sending when you want more consistent DingTalk rendering."
+        },
+        cardAtSender: {
+          label: "Card Mention Follow-Up",
+          help: "Send a follow-up @mention text after card finalization in group chats. Any non-empty string becomes the message body."
+        },
+        cardStatusLine: {
+          label: "Status Line",
+          help: "Configure which information segments appear in the AI card footer status line."
+        },
+        "cardStatusLine.model": {
+          label: "Model Name",
+          help: "Show the LLM model name in the AI card footer status line."
+        },
+        "cardStatusLine.effort": {
+          label: "Thinking Effort",
+          help: "Show the thinking effort level (e.g. high, medium) in the AI card footer."
+        },
+        "cardStatusLine.agent": {
+          label: "Agent Name",
+          help: "Show the agent display name in the AI card footer."
+        },
+        "cardStatusLine.taskTime": {
+          label: "Task Time",
+          help: "Show elapsed task time in the AI card footer."
+        },
+        "cardStatusLine.tokens": {
+          label: "Token Usage",
+          help: "Show a compact token usage summary (input/output/cache) in the AI card footer."
+        },
+        "cardStatusLine.dapiUsage": {
+          label: "API Calls",
+          help: "Show the DingTalk API call count in the AI card footer."
+        },
+        showThinkingStream: {
+          label: "Legacy Show Thinking Stream",
+          help: "Deprecated compatibility field from older card streaming behavior. The current runtime ignores it."
+        },
+        asyncMode: {
+          label: "Legacy Async Mode",
+          help: "Deprecated compatibility field from older host or runtime integrations. The current runtime ignores it."
+        },
+        accounts: {
+          label: "Named Accounts",
+          help: "Create named DingTalk accounts when one plugin instance must serve multiple apps or tenants."
+        },
+        "proactivePermissionHint.enabled": {
+          label: "Proactive Permission Hint Enabled",
+          help: "Show a reminder when DingTalk proactive-send permission has not been granted."
+        },
+        "proactivePermissionHint.cooldownHours": {
+          label: "Proactive Hint Cooldown (hours)",
+          help: "Minimum cooldown before the same proactive permission hint can be shown again."
+        }
+      }
+    }
+  }
 };
-var DingTalkAccountConfigSchema = z2.object(DingTalkAccountConfigShape);
-var DingTalkConfigSchema = DingTalkAccountConfigSchema.extend({
-  /** Multi-account configuration */
-  accounts: z2.record(z2.string(), DingTalkAccountConfigSchema.optional()).optional()
-});
 
 // src/gateway/channel-gateway.ts
 import { DWClient, TOPIC_CARD, TOPIC_ROBOT } from "dingtalk-stream";
+import { listAgentIds } from "openclaw/plugin-sdk/agent-runtime";
 
 // src/card/card-stop-handler.ts
 async function stopCardRun(params) {
@@ -14929,11 +15814,69 @@ function createDingTalkGateway() {
         debug: config.debug,
         baseLog: ctx.log
       });
+      try {
+        const knownGroupIds = /* @__PURE__ */ new Set();
+        for (const group of listKnownGroupTargets({
+          storePath: accountStorePath,
+          accountId: account.accountId
+        })) {
+          registerPeerId(group.conversationId);
+          knownGroupIds.add(group.conversationId.toLowerCase());
+        }
+        const runtime = getDingTalkRuntime();
+        for (const agentId of listAgentIds(cfg)) {
+          const sessionStorePath = runtime.channel.session.resolveStorePath(cfg.session?.store, {
+            agentId
+          });
+          for (const { entry } of runtime.agent.session.listSessionEntries({
+            agentId,
+            storePath: sessionStorePath,
+            readConsistency: "latest"
+          })) {
+            const isDingTalkSession = [
+              entry.lastChannel,
+              entry.channel,
+              entry.origin?.provider,
+              entry.origin?.surface
+            ].some((value) => value === "dingtalk");
+            const sessionAccountId = entry.lastAccountId || entry.origin?.accountId;
+            if (!isDingTalkSession || sessionAccountId !== account.accountId) {
+              continue;
+            }
+            for (const peerId of [entry.lastTo, entry.origin?.from, entry.origin?.to]) {
+              if (typeof peerId !== "string" || !peerId.startsWith("cid")) {
+                continue;
+              }
+              registerPeerId(peerId);
+              const normalizedPeerId = peerId.toLowerCase();
+              if (!knownGroupIds.has(normalizedPeerId)) {
+                upsertObservedGroupTarget({
+                  storePath: accountStorePath,
+                  accountId: account.accountId,
+                  conversationId: peerId,
+                  seenAt: entry.updatedAt
+                });
+                knownGroupIds.add(normalizedPeerId);
+              }
+            }
+          }
+        }
+        for (const user of listKnownUserTargets({
+          storePath: accountStorePath,
+          accountId: account.accountId
+        })) {
+          registerPeerId(user.canonicalUserId);
+          registerPeerId(user.staffId || "");
+          registerPeerId(user.senderId);
+        }
+      } catch (err) {
+        pluginLog?.warn?.(
+          `[${account.accountId}] Failed to restore peer IDs: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
       const runtimeConfig = await resolveRuntimeConfig(config, pluginLog);
       setCurrentLogger(pluginLog, account.accountId);
       pluginLog?.info?.(`[${account.accountId}] Initializing DingTalk Stream client...`);
-      preloadPeerIdsFromSessions();
-      pluginLog?.debug?.(`[${account.accountId}] Peer ID registry preloaded from sessions`);
       cleanupOrphanedTempFiles(pluginLog);
       try {
         const recovered = await recoverPendingCardsForAccount(
@@ -16013,10 +16956,9 @@ function describeDingTalkMessageTool(cfg) {
   if (!configured && !(config.accounts && Object.keys(config.accounts).length > 0)) {
     return { actions: [], capabilities: [], schema: null };
   }
-  const hasCardMode = config.messageType === "card" || config.accounts && Object.values(config.accounts).some((account) => account?.messageType === "card");
   return {
     actions: ["send"],
-    capabilities: hasCardMode ? ["cards"] : [],
+    capabilities: [],
     schema: null
   };
 }
@@ -16485,7 +17427,7 @@ var dingtalkPlugin = {
     blurb: "\u9489\u9489\u4F01\u4E1A\u5185\u90E8\u673A\u5668\u4EBA\uFF0C\u4F7F\u7528 Stream \u6A21\u5F0F\uFF0C\u65E0\u9700\u516C\u7F51 IP\u3002",
     aliases: ["dd", "ding"]
   },
-  configSchema: buildChannelConfigSchema(DingTalkConfigSchema),
+  configSchema: buildJsonChannelConfigSchema(openclaw_plugin_default.channelConfigs.dingtalk.schema),
   setup: dingtalkSetupAdapter,
   setupWizard: dingtalkSetupWizard,
   capabilities: {
@@ -16936,7 +17878,7 @@ var dingtalkEntry = defineChannelPluginEntry({
     );
   }
 });
-var index_default = {
+var pluginDefinition = {
   ...dingtalkEntry,
   register(api) {
     const registrationMode = api.registrationMode;
@@ -16950,9 +17892,9 @@ var index_default = {
     dingtalkEntry.register(api);
   }
 };
+var index_default = pluginDefinition;
 export {
   index_default as default,
   dingtalkPlugin,
   setDingTalkRuntime
 };
-//# sourceMappingURL=index.js.map