@marshulll/openclaw-wecom 0.1.19 → 0.1.21

package/node_modules/zip-stream/node_modules/readable-stream/lib/internal/streams/state.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;
+function highWaterMarkFrom(options, isDuplex, duplexKey) {
+  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
+}
+function getHighWaterMark(state, options, duplexKey, isDuplex) {
+  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
+  if (hwm != null) {
+    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
+      var name = isDuplex ? duplexKey : 'highWaterMark';
+      throw new ERR_INVALID_OPT_VALUE(name, hwm);
+    }
+    return Math.floor(hwm);
+  }
+
+  // Default value
+  return state.objectMode ? 16 : 16 * 1024;
+}
+module.exports = {
+  getHighWaterMark: getHighWaterMark
+};

package/node_modules/zip-stream/node_modules/readable-stream/lib/internal/streams/stream-browser.js

@@ -0,0 +1 @@
+module.exports = require('events').EventEmitter;

package/node_modules/zip-stream/node_modules/readable-stream/lib/internal/streams/stream.js

@@ -0,0 +1 @@
+module.exports = require('stream');

package/node_modules/zip-stream/node_modules/readable-stream/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "readable-stream",
+  "version": "3.6.2",
+  "description": "Streams3, a user-land copy of the stream library from Node.js",
+  "main": "readable.js",
+  "engines": {
+    "node": ">= 6"
+  },
+  "dependencies": {
+    "inherits": "^2.0.3",
+    "string_decoder": "^1.1.1",
+    "util-deprecate": "^1.0.1"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.2.0",
+    "@babel/core": "^7.2.0",
+    "@babel/polyfill": "^7.0.0",
+    "@babel/preset-env": "^7.2.0",
+    "airtap": "0.0.9",
+    "assert": "^1.4.0",
+    "bl": "^2.0.0",
+    "deep-strict-equal": "^0.2.0",
+    "events.once": "^2.0.2",
+    "glob": "^7.1.2",
+    "gunzip-maybe": "^1.4.1",
+    "hyperquest": "^2.1.3",
+    "lolex": "^2.6.0",
+    "nyc": "^11.0.0",
+    "pump": "^3.0.0",
+    "rimraf": "^2.6.2",
+    "tap": "^12.0.0",
+    "tape": "^4.9.0",
+    "tar-fs": "^1.16.2",
+    "util-promisify": "^2.1.0"
+  },
+  "scripts": {
+    "test": "tap -J --no-esm test/parallel/*.js test/ours/*.js",
+    "ci": "TAP=1 tap --no-esm test/parallel/*.js test/ours/*.js | tee test.tap",
+    "test-browsers": "airtap --sauce-connect --loopback airtap.local -- test/browser.js",
+    "test-browser-local": "airtap --open --local -- test/browser.js",
+    "cover": "nyc npm test",
+    "report": "nyc report --reporter=lcov",
+    "update-browser-errors": "babel -o errors-browser.js errors.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/nodejs/readable-stream"
+  },
+  "keywords": [
+    "readable",
+    "stream",
+    "pipe"
+  ],
+  "browser": {
+    "util": false,
+    "worker_threads": false,
+    "./errors": "./errors-browser.js",
+    "./readable.js": "./readable-browser.js",
+    "./lib/internal/streams/from.js": "./lib/internal/streams/from-browser.js",
+    "./lib/internal/streams/stream.js": "./lib/internal/streams/stream-browser.js"
+  },
+  "nyc": {
+    "include": [
+      "lib/**.js"
+    ]
+  },
+  "license": "MIT"
+}

package/node_modules/zip-stream/node_modules/readable-stream/readable-browser.js

@@ -0,0 +1,9 @@
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = exports;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+exports.finished = require('./lib/internal/streams/end-of-stream.js');
+exports.pipeline = require('./lib/internal/streams/pipeline.js');

package/node_modules/zip-stream/node_modules/readable-stream/readable.js

@@ -0,0 +1,16 @@
+var Stream = require('stream');
+if (process.env.READABLE_STREAM === 'disable' && Stream) {
+  module.exports = Stream.Readable;
+  Object.assign(module.exports, Stream);
+  module.exports.Stream = Stream;
+} else {
+  exports = module.exports = require('./lib/_stream_readable.js');
+  exports.Stream = Stream || exports;
+  exports.Readable = exports;
+  exports.Writable = require('./lib/_stream_writable.js');
+  exports.Duplex = require('./lib/_stream_duplex.js');
+  exports.Transform = require('./lib/_stream_transform.js');
+  exports.PassThrough = require('./lib/_stream_passthrough.js');
+  exports.finished = require('./lib/internal/streams/end-of-stream.js');
+  exports.pipeline = require('./lib/internal/streams/pipeline.js');
+}

package/node_modules/zip-stream/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "zip-stream",
+  "version": "5.0.2",
+  "description": "a streaming zip archive generator.",
+  "homepage": "https://github.com/archiverjs/node-zip-stream",
+  "author": {
+    "name": "Chris Talkington",
+    "url": "http://christalkington.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/archiverjs/node-zip-stream.git"
+  },
+  "bugs": {
+    "url": "https://github.com/archiverjs/node-zip-stream/issues"
+  },
+  "license": "MIT",
+  "main": "index.js",
+  "files": [
+    "index.js"
+  ],
+  "engines": {
+    "node": ">= 12.0.0"
+  },
+  "scripts": {
+    "test": "mocha --reporter dot",
+    "jsdoc": "jsdoc -c jsdoc.json README.md"
+  },
+  "dependencies": {
+    "archiver-utils": "^4.0.1",
+    "compress-commons": "^5.0.1",
+    "readable-stream": "^3.6.0"
+  },
+  "devDependencies": {
+    "archiver-jsdoc-theme": "1.1.3",
+    "chai": "4.4.1",
+    "jsdoc": "3.6.11",
+    "minami": "1.2.3",
+    "mkdirp": "3.0.1",
+    "mocha": "9.2.2",
+    "rimraf": "5.0.5"
+  },
+  "keywords": [
+    "archive",
+    "stream",
+    "zip-stream",
+    "zip"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marshulll/openclaw-wecom",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "type": "module",
   "description": "OpenClaw WeCom channel plugin (intelligent bot + internal app)",
   "author": "OpenClaw",
@@ -36,10 +36,12 @@
     "openclaw": ">=2026.1.25"
   },
   "dependencies": {
+    "archiver": "^6.0.2",
     "fast-xml-parser": "^4.3.6",
     "zod": "^3.23.8"
   },
   "bundledDependencies": [
+    "archiver",
     "fast-xml-parser",
     "zod"
   ],

package/wecom/src/commands.ts

@@ -1,6 +1,9 @@
 import type { ClawdbotConfig } from "openclaw/plugin-sdk";
-import { readFile, stat } from "node:fs/promises";
-import { basename } from "node:path";
+import { createWriteStream } from "node:fs";
+import { appendFile, mkdir, mkdtemp, readFile, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import archiver from "archiver";
 
 import { getWecomRuntime } from "./runtime.js";
 import { listWecomAccountIds } from "./accounts.js";
@@ -35,10 +38,51 @@ function parseQuotedArgs(raw: string): string[] {
   return args;
 }
 
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function resolveSendIntervalMs(ctx: CommandContext): number {
+  const interval = ctx.account.config.sendQueue?.intervalMs;
+  return typeof interval === "number" && interval >= 0 ? interval : 400;
+}
+
+async function appendOperationLog(ctx: CommandContext, entry: Record<string, unknown>): Promise<void> {
+  const logPath = ctx.account.config.operations?.logPath?.trim();
+  if (!logPath) return;
+  try {
+    await mkdir(dirname(logPath), { recursive: true });
+    await appendFile(logPath, `${JSON.stringify({ ts: new Date().toISOString(), ...entry })}\n`);
+  } catch {
+    // ignore
+  }
+}
+
+async function zipDirectory(sourceDir: string): Promise<{ zipPath: string; cleanup: () => Promise<void> }> {
+  const tempDir = await mkdtemp(join(tmpdir(), "openclaw-wecom-zip-"));
+  const zipPath = join(tempDir, `${basename(sourceDir)}.zip`);
+  await new Promise<void>((resolve, reject) => {
+    const output = createWriteStream(zipPath);
+    const archive = archiver("zip", { zlib: { level: 9 } });
+    output.on("close", () => resolve());
+    archive.on("error", (err) => reject(err));
+    archive.pipe(output);
+    archive.directory(sourceDir, false);
+    archive.finalize();
+  });
+  return {
+    zipPath,
+    cleanup: async () => {
+      await rm(tempDir, { recursive: true, force: true });
+    },
+  };
+}
+
 async function sendFiles(ctx: CommandContext, paths: string[]): Promise<{ sent: number; skipped: number }> {
   let sent = 0;
   let skipped = 0;
   const maxBytes = ctx.account.config.media?.maxBytes;
+  const intervalMs = resolveSendIntervalMs(ctx);
   for (const rawPath of paths) {
     const path = rawPath.startsWith("file://") ? rawPath.replace(/^file:\/\//, "") : rawPath;
     if (!path.startsWith("/")) {
@@ -46,20 +90,30 @@ async function sendFiles(ctx: CommandContext, paths: string[]): Promise<{ sent:
       await sendAndRecord(ctx, `⚠️ 路径需为绝对路径：${rawPath}`);
       continue;
     }
+    let cleanup: (() => Promise<void>) | null = null;
     try {
       const info = await stat(path);
-      if (!info.isFile()) {
+      let sendPath = path;
+
+      if (info.isDirectory()) {
+        const zipped = await zipDirectory(path);
+        sendPath = zipped.zipPath;
+        cleanup = zipped.cleanup;
+      } else if (!info.isFile()) {
         skipped += 1;
-        await sendAndRecord(ctx, `⚠️ 不是文件：${path}`);
+        await sendAndRecord(ctx, `⚠️ 不是文件或文件夹：${path}`);
         continue;
       }
-      if (typeof maxBytes === "number" && maxBytes > 0 && info.size > maxBytes) {
+
+      const sendInfo = await stat(sendPath);
+      if (typeof maxBytes === "number" && maxBytes > 0 && sendInfo.size > maxBytes) {
         skipped += 1;
-        await sendAndRecord(ctx, `⚠️ 文件过大(${info.size} bytes)：${path}`);
+        await sendAndRecord(ctx, `⚠️ 文件过大(${sendInfo.size} bytes)：${sendPath}`);
+        if (cleanup) await cleanup();
         continue;
       }
-      const buffer = await readFile(path);
-      const filename = basename(path) || "file.bin";
+      const buffer = await readFile(sendPath);
+      const filename = basename(sendPath) || "file.bin";
       const mediaId = await uploadWecomMedia({
         account: ctx.account,
         type: "file",
@@ -73,9 +127,37 @@ async function sendFiles(ctx: CommandContext, paths: string[]): Promise<{ sent:
         mediaId,
       });
       sent += 1;
+      await appendOperationLog(ctx, {
+        action: "sendfile",
+        accountId: ctx.account.accountId,
+        toUser: ctx.fromUser,
+        chatId: ctx.chatId,
+        path,
+        resolvedPath: sendPath,
+        size: sendInfo.size,
+      });
+      if (cleanup) await cleanup();
+      if (intervalMs) {
+        await sleep(intervalMs);
+      }
     } catch (err) {
       skipped += 1;
       await sendAndRecord(ctx, `⚠️ 发送失败：${path} (${String(err)})`);
+      await appendOperationLog(ctx, {
+        action: "sendfile",
+        accountId: ctx.account.accountId,
+        toUser: ctx.fromUser,
+        chatId: ctx.chatId,
+        path,
+        error: String(err),
+      });
+      if (cleanup) {
+        try {
+          await cleanup();
+        } catch {
+          // ignore cleanup failure
+        }
+      }
     }
   }
   ctx.statusSink?.({ lastOutboundAt: Date.now() });

package/wecom/src/config-schema.ts

@@ -58,6 +58,29 @@ const accountSchema = z.object({
       timeoutMs: z.number().optional(),
       maxBytes: z.number().optional(),
     }).optional(),
+    auto: z.object({
+      enabled: z.boolean().optional(),
+      file: z.object({
+        enabled: z.boolean().optional(),
+        textMaxBytes: z.number().optional(),
+        textMaxChars: z.number().optional(),
+        extensions: z.array(z.string()).optional(),
+      }).optional(),
+      audio: z.object({
+        enabled: z.boolean().optional(),
+        baseUrl: z.string().optional(),
+        apiKey: z.string().optional(),
+        model: z.string().optional(),
+        prompt: z.string().optional(),
+        timeoutMs: z.number().optional(),
+        maxBytes: z.number().optional(),
+      }).optional(),
+      video: z.object({
+        enabled: z.boolean().optional(),
+        ffmpegPath: z.string().optional(),
+        maxBytes: z.number().optional(),
+      }).optional(),
+    }).optional(),
   }).optional(),
 
   network: z.object({
@@ -67,6 +90,14 @@ const accountSchema = z.object({
   }).optional(),
 
   botMediaBridge: z.boolean().optional(),
+
+  sendQueue: z.object({
+    intervalMs: z.number().optional(),
+  }).optional(),
+
+  operations: z.object({
+    logPath: z.string().optional(),
+  }).optional(),
 });
 
 export const WecomConfigSchema = ensureJsonSchema(z.object({
@@ -103,6 +134,29 @@ export const WecomConfigSchema = ensureJsonSchema(z.object({
       timeoutMs: z.number().optional(),
       maxBytes: z.number().optional(),
     }).optional(),
+    auto: z.object({
+      enabled: z.boolean().optional(),
+      file: z.object({
+        enabled: z.boolean().optional(),
+        textMaxBytes: z.number().optional(),
+        textMaxChars: z.number().optional(),
+        extensions: z.array(z.string()).optional(),
+      }).optional(),
+      audio: z.object({
+        enabled: z.boolean().optional(),
+        baseUrl: z.string().optional(),
+        apiKey: z.string().optional(),
+        model: z.string().optional(),
+        prompt: z.string().optional(),
+        timeoutMs: z.number().optional(),
+        maxBytes: z.number().optional(),
+      }).optional(),
+      video: z.object({
+        enabled: z.boolean().optional(),
+        ffmpegPath: z.string().optional(),
+        maxBytes: z.number().optional(),
+      }).optional(),
+    }).optional(),
   }).optional(),
 
   network: z.object({
@@ -113,6 +167,14 @@ export const WecomConfigSchema = ensureJsonSchema(z.object({
 
   botMediaBridge: z.boolean().optional(),
 
+  sendQueue: z.object({
+    intervalMs: z.number().optional(),
+  }).optional(),
+
+  operations: z.object({
+    logPath: z.string().optional(),
+  }).optional(),
+
   defaultAccount: z.string().optional(),
   accounts: z.object({}).catchall(accountSchema).optional(),
 }));

package/wecom/src/media-auto.ts

@@ -0,0 +1,220 @@
+import { readFile, stat, writeFile, mkdtemp, rm } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { tmpdir } from "node:os";
+import { basename, extname, join } from "node:path";
+
+import type { WecomAccountConfig } from "./types.js";
+import { describeImageWithVision, resolveVisionConfig } from "./media-vision.js";
+
+const DEFAULT_TEXT_EXTENSIONS = ["txt", "md", "log", "csv", "json", "xml", "yaml", "yml"];
+
+export type AutoAudioConfig = {
+  enabled?: boolean;
+  baseUrl?: string;
+  apiKey?: string;
+  model?: string;
+  prompt?: string;
+  timeoutMs?: number;
+  maxBytes?: number;
+};
+
+export type AutoFileConfig = {
+  enabled?: boolean;
+  textMaxBytes?: number;
+  textMaxChars?: number;
+  extensions?: string[];
+};
+
+export type AutoVideoConfig = {
+  enabled?: boolean;
+  ffmpegPath?: string;
+  maxBytes?: number;
+};
+
+export type ResolvedAutoAudioConfig = {
+  baseUrl: string;
+  apiKey: string;
+  model: string;
+  prompt?: string;
+  timeoutMs: number;
+  maxBytes?: number;
+};
+
+export type ResolvedAutoFileConfig = {
+  textMaxBytes: number;
+  textMaxChars: number;
+  extensions: string[];
+};
+
+export type ResolvedAutoVideoConfig = {
+  ffmpegPath: string;
+  maxBytes?: number;
+};
+
+export function resolveAutoAudioConfig(cfg: WecomAccountConfig): ResolvedAutoAudioConfig | null {
+  const audio = cfg.media?.auto?.audio;
+  if (!cfg.media?.auto?.enabled || !audio?.enabled) return null;
+  const baseUrl = audio.baseUrl?.trim() || "";
+  const apiKey = audio.apiKey?.trim() || "";
+  const model = audio.model?.trim() || "";
+  if (!baseUrl || !apiKey || !model) return null;
+  return {
+    baseUrl,
+    apiKey,
+    model,
+    prompt: audio.prompt?.trim() || undefined,
+    timeoutMs: typeof audio.timeoutMs === "number" && audio.timeoutMs > 0 ? audio.timeoutMs : 15000,
+    maxBytes: typeof audio.maxBytes === "number" && audio.maxBytes > 0 ? audio.maxBytes : undefined,
+  };
+}
+
+export function resolveAutoFileConfig(cfg: WecomAccountConfig): ResolvedAutoFileConfig | null {
+  const fileCfg = cfg.media?.auto?.file;
+  if (!cfg.media?.auto?.enabled || !fileCfg?.enabled) return null;
+  const textMaxBytes = typeof fileCfg.textMaxBytes === "number" && fileCfg.textMaxBytes > 0
+    ? fileCfg.textMaxBytes
+    : 200_000;
+  const textMaxChars = typeof fileCfg.textMaxChars === "number" && fileCfg.textMaxChars > 0
+    ? fileCfg.textMaxChars
+    : 4000;
+  const extensions = (fileCfg.extensions && fileCfg.extensions.length > 0
+    ? fileCfg.extensions
+    : DEFAULT_TEXT_EXTENSIONS).map((ext) => ext.toLowerCase());
+  return { textMaxBytes, textMaxChars, extensions };
+}
+
+export function resolveAutoVideoConfig(cfg: WecomAccountConfig): ResolvedAutoVideoConfig | null {
+  const video = cfg.media?.auto?.video;
+  if (!cfg.media?.auto?.enabled || !video?.enabled) return null;
+  return {
+    ffmpegPath: video.ffmpegPath?.trim() || "ffmpeg",
+    maxBytes: typeof video.maxBytes === "number" && video.maxBytes > 0 ? video.maxBytes : undefined,
+  };
+}
+
+function looksLikeText(buffer: Buffer): boolean {
+  const sample = buffer.subarray(0, Math.min(buffer.length, 4096));
+  for (const byte of sample) {
+    if (byte === 0) return false;
+  }
+  return true;
+}
+
+function isAllowedTextFile(path: string, mimeType: string | undefined, cfg: ResolvedAutoFileConfig): boolean {
+  if (mimeType && mimeType.startsWith("text/")) return true;
+  const ext = extname(path).replace(".", "").toLowerCase();
+  if (!ext) return false;
+  return cfg.extensions.includes(ext);
+}
+
+export async function extractFileTextPreview(params: {
+  path: string;
+  mimeType?: string;
+  cfg: ResolvedAutoFileConfig;
+}): Promise<string | null> {
+  const info = await stat(params.path);
+  if (info.size > params.cfg.textMaxBytes) return null;
+  if (!isAllowedTextFile(params.path, params.mimeType, params.cfg)) return null;
+  const buffer = await readFile(params.path);
+  if (!looksLikeText(buffer)) return null;
+  const text = buffer.toString("utf8").trim();
+  if (!text) return null;
+  return text.slice(0, params.cfg.textMaxChars);
+}
+
+export async function transcribeAudioWithOpenAI(params: {
+  cfg: ResolvedAutoAudioConfig;
+  buffer: Buffer;
+  mimeType?: string;
+}): Promise<string | null> {
+  if (params.cfg.maxBytes && params.buffer.length > params.cfg.maxBytes) return null;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), params.cfg.timeoutMs);
+  try {
+    const form = new FormData();
+    const mimeType = params.mimeType || "audio/amr";
+    form.append("file", new Blob([params.buffer], { type: mimeType }), `audio.${mimeType.split("/")[1] || "amr"}`);
+    form.append("model", params.cfg.model);
+    if (params.cfg.prompt) form.append("prompt", params.cfg.prompt);
+
+    const res = await fetch(`${params.cfg.baseUrl.replace(/\/$/, "")}/audio/transcriptions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${params.cfg.apiKey}`,
+      },
+      body: form,
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      return null;
+    }
+    const json = await res.json();
+    const text = typeof json.text === "string" ? json.text : typeof json?.data?.text === "string" ? json.data.text : "";
+    return text.trim() || null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function runFfmpegExtractFrame(params: {
+  ffmpegPath: string;
+  videoPath: string;
+  framePath: string;
+}): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    const proc = spawn(params.ffmpegPath, [
+      "-y",
+      "-i",
+      params.videoPath,
+      "-frames:v",
+      "1",
+      "-q:v",
+      "2",
+      params.framePath,
+    ]);
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`ffmpeg exited with code ${code ?? "unknown"}`));
+    });
+  });
+}
+
+export async function summarizeVideoWithVision(params: {
+  cfg: ResolvedAutoVideoConfig;
+  account: WecomAccountConfig;
+  videoPath: string;
+}): Promise<string | null> {
+  const info = await stat(params.videoPath);
+  if (params.cfg.maxBytes && info.size > params.cfg.maxBytes) return null;
+  const visionConfig = resolveVisionConfig(params.account);
+  if (!visionConfig) return null;
+
+  const tempDir = await mkdtemp(join(tmpdir(), "openclaw-wecom-frame-"));
+  const framePath = join(tempDir, `${basename(params.videoPath)}.jpg`);
+  try {
+    await runFfmpegExtractFrame({
+      ffmpegPath: params.cfg.ffmpegPath,
+      videoPath: params.videoPath,
+      framePath,
+    });
+    const buffer = await readFile(framePath);
+    if (!buffer.length) return null;
+    const summary = await describeImageWithVision({
+      config: visionConfig,
+      buffer,
+      mimeType: "image/jpeg",
+    });
+    return summary ?? null;
+  } catch {
+    return null;
+  } finally {
+    try {
+      await rm(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup
+    }
+  }
+}

package/wecom/src/types.ts

@@ -58,6 +58,29 @@ export type WecomAccountConfig = {
       timeoutMs?: number;
       maxBytes?: number;
     };
+    auto?: {
+      enabled?: boolean;
+      file?: {
+        enabled?: boolean;
+        textMaxBytes?: number;
+        textMaxChars?: number;
+        extensions?: string[];
+      };
+      audio?: {
+        enabled?: boolean;
+        baseUrl?: string;
+        apiKey?: string;
+        model?: string;
+        prompt?: string;
+        timeoutMs?: number;
+        maxBytes?: number;
+      };
+      video?: {
+        enabled?: boolean;
+        ffmpegPath?: string;
+        maxBytes?: number;
+      };
+    };
   };
 
   // Network behavior
@@ -69,6 +92,16 @@ export type WecomAccountConfig = {
 
   // If true (default), bot mode can bridge media via app send APIs.
   botMediaBridge?: boolean;
+
+  // Send queue behavior (e.g., /sendfile)
+  sendQueue?: {
+    intervalMs?: number;
+  };
+
+  // Operation logs (optional)
+  operations?: {
+    logPath?: string;
+  };
 };
 
 export type WecomConfig = WecomAccountConfig & {