@yanhaidao/wecom 2.4.120 → 2.5.110

package/{src/dynamic-agent.ts → dist/src/dynamic-agent.js}

@@ -4,23 +4,13 @@
  * 为每个用户/群组自动生成独立的 Agent ID，实现会话隔离。
  * 参考: openclaw-plugin-wecom/dynamic-agent.js
  */
-
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-
-export interface DynamicAgentConfig {
-    enabled: boolean;
-    dmCreateAgent: boolean;
-    groupEnabled: boolean;
-    adminUsers: string[];
-}
-
 /**
  * **getDynamicAgentConfig (读取动态 Agent 配置)**
  *
  * 从全局配置中读取动态 Agent 配置，提供默认值。
  */
-export function getDynamicAgentConfig(config: OpenClawConfig): DynamicAgentConfig {
-    const dynamicAgents = (config as { channels?: { wecom?: { dynamicAgents?: Partial<DynamicAgentConfig> } } })?.channels?.wecom?.dynamicAgents;
+export function getDynamicAgentConfig(config) {
+    const dynamicAgents = config?.channels?.wecom?.dynamicAgents;
     return {
         enabled: dynamicAgents?.enabled ?? false,
         dmCreateAgent: dynamicAgents?.dmCreateAgent ?? true,
@@ -28,114 +18,89 @@ export function getDynamicAgentConfig(config: OpenClawConfig): DynamicAgentConfi
         adminUsers: dynamicAgents?.adminUsers ?? [],
     };
 }
-
-function sanitizeDynamicIdPart(value: string): string {
+function sanitizeDynamicIdPart(value) {
     return String(value)
         .trim()
         .toLowerCase()
         .replace(/[^a-z0-9_-]/g, "_");
 }
-
 /**
  * **generateAgentId (生成动态 Agent ID)**
  *
  * 根据账号 + 聊天类型 + 对端 ID 生成确定性的 Agent ID，避免多账号串会话。
  * 格式: wecom-{accountId}-{type}-{sanitizedPeerId}
  */
-export function generateAgentId(chatType: "dm" | "group", peerId: string, accountId?: string): string {
+export function generateAgentId(chatType, peerId, accountId) {
     const sanitizedPeer = sanitizeDynamicIdPart(peerId) || "unknown";
     const sanitizedAccountId = sanitizeDynamicIdPart(accountId ?? "default") || "default";
     return `wecom-${sanitizedAccountId}-${chatType}-${sanitizedPeer}`;
 }
-
-export function buildAgentSessionTarget(userId: string, accountId?: string): string {
+export function buildAgentSessionTarget(userId, accountId) {
     const normalizedUserId = String(userId).trim();
     const sanitizedAccountId = sanitizeDynamicIdPart(accountId ?? "default") || "default";
     // Always use explicit user: prefix to avoid ambiguity with numeric party IDs
     return `wecom-agent:${sanitizedAccountId}:user:${normalizedUserId}`;
 }
-
 /**
  * **shouldUseDynamicAgent (检查是否使用动态 Agent)**
  *
  * 根据配置和发送者信息判断是否应使用动态 Agent。
  * 管理员（adminUsers）始终绕过动态路由，使用主 Agent。
  */
-export function shouldUseDynamicAgent(params: {
-    chatType: "dm" | "group";
-    senderId: string;
-    config: OpenClawConfig;
-}): boolean {
+export function shouldUseDynamicAgent(params) {
     const { chatType, senderId, config } = params;
     const dynamicConfig = getDynamicAgentConfig(config);
-
     if (!dynamicConfig.enabled) {
         return false;
     }
-
     // 管理员绕过动态路由
     const sender = String(senderId).trim().toLowerCase();
-    const isAdmin = dynamicConfig.adminUsers.some(
-        (admin) => admin.trim().toLowerCase() === sender
-    );
+    const isAdmin = dynamicConfig.adminUsers.some((admin) => admin.trim().toLowerCase() === sender);
     if (isAdmin) {
         return false;
     }
-
     if (chatType === "group") {
         return dynamicConfig.groupEnabled;
     }
     return dynamicConfig.dmCreateAgent;
 }
-
 /**
  * 内存中已确保的 Agent ID（避免重复写入）
  */
-const ensuredDynamicAgentIds = new Set<string>();
-
+const ensuredDynamicAgentIds = new Set();
 /**
  * 写入队列（避免并发冲突）
  */
-let ensureDynamicAgentWriteQueue: Promise<void> = Promise.resolve();
-
+let ensureDynamicAgentWriteQueue = Promise.resolve();
 /**
  * 将 Agent ID 插入 agents.list（如果不存在）
  */
-function upsertAgentIdOnlyEntry(cfg: Record<string, unknown>, agentId: string): boolean {
+function upsertAgentIdOnlyEntry(cfg, agentId) {
     if (!cfg.agents || typeof cfg.agents !== "object") {
         cfg.agents = {};
     }
-
-    const agentsObj = cfg.agents as Record<string, unknown>;
-    const currentList: Array<{ id: string }> = Array.isArray(agentsObj.list) ? agentsObj.list as Array<{ id: string }> : [];
-    const existingIds = new Set(
-        currentList
-            .map((entry) => entry?.id?.trim().toLowerCase())
-            .filter((id): id is string => Boolean(id))
-    );
-
+    const agentsObj = cfg.agents;
+    const currentList = Array.isArray(agentsObj.list) ? agentsObj.list : [];
+    const existingIds = new Set(currentList
+        .map((entry) => entry?.id?.trim().toLowerCase())
+        .filter((id) => Boolean(id)));
     let changed = false;
     const nextList = [...currentList];
-
     // 首次创建时保留 main 作为默认
     if (nextList.length === 0) {
         nextList.push({ id: "main" });
         existingIds.add("main");
         changed = true;
     }
-
     if (!existingIds.has(agentId.toLowerCase())) {
         nextList.push({ id: agentId });
         changed = true;
     }
-
     if (changed) {
         agentsObj.list = nextList;
     }
-
     return changed;
 }
-
 /**
  * **ensureDynamicAgentListed (确保动态 Agent 已添加到 agents.list)**
  *
@@ -146,40 +111,38 @@ function upsertAgentIdOnlyEntry(cfg: Record<string, unknown>, agentId: string):
  * - 异步：不阻塞消息处理流程
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export async function ensureDynamicAgentListed(agentId: string, runtime: any): Promise<void> {
+export async function ensureDynamicAgentListed(agentId, runtime) {
     const normalizedId = String(agentId).trim().toLowerCase();
-    if (!normalizedId) return;
-    if (ensuredDynamicAgentIds.has(normalizedId)) return;
-
+    if (!normalizedId)
+        return;
+    if (ensuredDynamicAgentIds.has(normalizedId))
+        return;
     const configRuntime = runtime?.config;
-    if (!configRuntime?.loadConfig || !configRuntime?.writeConfigFile) return;
-
+    if (!configRuntime?.loadConfig || !configRuntime?.writeConfigFile)
+        return;
     ensureDynamicAgentWriteQueue = ensureDynamicAgentWriteQueue
         .then(async () => {
-            if (ensuredDynamicAgentIds.has(normalizedId)) return;
-
-            const latestConfig = configRuntime.loadConfig!();
-            if (!latestConfig || typeof latestConfig !== "object") return;
-
-            const changed = upsertAgentIdOnlyEntry(latestConfig as Record<string, unknown>, normalizedId);
-            if (changed) {
-                await configRuntime.writeConfigFile!(latestConfig as unknown);
-            }
-
-            ensuredDynamicAgentIds.add(normalizedId);
-        })
+        if (ensuredDynamicAgentIds.has(normalizedId))
+            return;
+        const latestConfig = configRuntime.loadConfig();
+        if (!latestConfig || typeof latestConfig !== "object")
+            return;
+        const changed = upsertAgentIdOnlyEntry(latestConfig, normalizedId);
+        if (changed) {
+            await configRuntime.writeConfigFile(latestConfig);
+        }
+        ensuredDynamicAgentIds.add(normalizedId);
+    })
         .catch((err) => {
-            console.warn(`[wecom] 动态 Agent 添加失败: ${normalizedId}`, err);
-        });
-
+        console.warn(`[wecom] 动态 Agent 添加失败: ${normalizedId}`, err);
+    });
     await ensureDynamicAgentWriteQueue;
 }
-
 /**
  * **resetEnsuredCache (重置已确保缓存)**
  *
  * 主要用于测试场景，重置内存中的缓存状态。
  */
-export function resetEnsuredCache(): void {
+export function resetEnsuredCache() {
     ensuredDynamicAgentIds.clear();
 }

package/dist/src/gateway-monitor.js

@@ -0,0 +1,139 @@
+import { listWecomAccountIds, resolveWecomAccount, resolveWecomAccountConflict, } from "./config/index.js";
+import { createAccountRuntime } from "./app/bootstrap.js";
+import { registerAccountRuntime, unregisterAccountRuntime } from "./app/index.js";
+import { WecomBotCapabilityService } from "./capability/bot/index.js";
+import { WecomAgentIngressService } from "./capability/agent/index.js";
+const accountRouteRegistry = new Map();
+function logRegisteredRouteSummary(ctx, preferredOrder) {
+    const seen = new Set();
+    const orderedAccountIds = [
+        ...preferredOrder.filter((accountId) => accountRouteRegistry.has(accountId)),
+        ...Array.from(accountRouteRegistry.keys())
+            .filter((accountId) => !seen.has(accountId))
+            .sort((a, b) => a.localeCompare(b)),
+    ].filter((accountId) => {
+        if (seen.has(accountId))
+            return false;
+        seen.add(accountId);
+        return true;
+    });
+    const entries = orderedAccountIds
+        .map((accountId) => {
+        const routes = accountRouteRegistry.get(accountId);
+        if (!routes)
+            return undefined;
+        const botText = routes.botPaths.length > 0 ? routes.botPaths.join(", ") : "未启用";
+        const agentText = routes.agentPaths.length > 0 ? routes.agentPaths.join(", ") : "未启用";
+        return `accountId=${accountId}（Bot: ${botText}；Agent: ${agentText}）`;
+    })
+        .filter((entry) => Boolean(entry));
+    const summary = entries.length > 0 ? entries.join("； ") : "无";
+    ctx.log?.info(`[${ctx.account.accountId}] 已注册账号路由汇总：${summary}`);
+}
+function resolveExpectedRouteSummaryAccountIds(cfg) {
+    return listWecomAccountIds(cfg)
+        .filter((accountId) => {
+        const conflict = resolveWecomAccountConflict({ cfg, accountId });
+        if (conflict)
+            return false;
+        const account = resolveWecomAccount({ cfg, accountId });
+        if (!account.enabled || !account.configured)
+            return false;
+        return Boolean(account.bot?.configured || account.agent?.configured);
+    })
+        .sort((a, b) => a.localeCompare(b));
+}
+function waitForAbortSignal(abortSignal) {
+    if (abortSignal.aborted) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        const onAbort = () => {
+            abortSignal.removeEventListener("abort", onAbort);
+            resolve();
+        };
+        abortSignal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+/**
+ * Keeps WeCom webhook targets registered for the account lifecycle.
+ * The promise only settles after gateway abort/reload signals shutdown.
+ */
+export async function monitorWecomProvider(ctx) {
+    const account = ctx.account;
+    const cfg = ctx.cfg;
+    const expectedRouteSummaryAccountIds = resolveExpectedRouteSummaryAccountIds(cfg);
+    const conflict = resolveWecomAccountConflict({
+        cfg,
+        accountId: account.accountId,
+    });
+    if (conflict) {
+        ctx.setStatus({
+            accountId: account.accountId,
+            running: false,
+            configured: false,
+            lastError: conflict.message,
+        });
+        throw new Error(conflict.message);
+    }
+    const bot = account.bot;
+    const agent = account.agent;
+    const botConfigured = Boolean(bot?.configured);
+    const agentConfigured = Boolean(agent?.configured);
+    if (!botConfigured && !agentConfigured) {
+        ctx.log?.warn(`[${account.accountId}] wecom not configured; channel is idle`);
+        ctx.setStatus({ accountId: account.accountId, running: false, configured: false });
+        await waitForAbortSignal(ctx.abortSignal);
+        return;
+    }
+    const accountRuntime = createAccountRuntime(ctx);
+    registerAccountRuntime(accountRuntime);
+    const botPaths = [];
+    const agentPaths = [];
+    const runtimeEnv = {
+        log: (message) => ctx.log?.info(message),
+        error: (message) => ctx.log?.error(message),
+    };
+    const botService = new WecomBotCapabilityService(accountRuntime, cfg, runtimeEnv);
+    const agentIngress = new WecomAgentIngressService(accountRuntime, cfg, runtimeEnv);
+    try {
+        ctx.log?.info(`[${account.accountId}] wecom runtime start bot=${bot?.primaryTransport ?? "disabled"} agent=${agentConfigured ? "callback/api" : "disabled"}`);
+        const botRegistration = botService.start();
+        if (botRegistration) {
+            botPaths.push(...botRegistration.descriptors);
+            ctx.log?.info(`[${account.accountId}] wecom bot ${botRegistration.transport} started: ${botRegistration.descriptors.join(", ")}`);
+        }
+        const agentRegistration = agentIngress.start();
+        if (agentRegistration) {
+            agentPaths.push(...agentRegistration.descriptors);
+            ctx.log?.info(`[${account.accountId}] wecom agent ${agentRegistration.transport} started: ${agentRegistration.descriptors.join(", ")}`);
+        }
+        accountRouteRegistry.set(account.accountId, { botPaths, agentPaths });
+        const shouldLogSummary = expectedRouteSummaryAccountIds.length <= 1 ||
+            expectedRouteSummaryAccountIds.every((accountId) => accountRouteRegistry.has(accountId));
+        if (shouldLogSummary) {
+            logRegisteredRouteSummary(ctx, expectedRouteSummaryAccountIds);
+        }
+        ctx.setStatus({
+            running: true,
+            configured: true,
+            webhookPath: botPaths[0] ?? agentPaths[0] ?? null,
+            lastStartAt: Date.now(),
+            ...accountRuntime.buildRuntimeStatus(),
+        });
+        ctx.log?.info(`[${account.accountId}] runtime status health=${accountRuntime.buildRuntimeStatus().health} transports=${(accountRuntime.buildRuntimeStatus().transportSessions ?? []).join(" | ") || "none"}`);
+        await waitForAbortSignal(ctx.abortSignal);
+    }
+    finally {
+        botService.stop();
+        agentIngress.stop();
+        accountRouteRegistry.delete(account.accountId);
+        unregisterAccountRuntime(account.accountId);
+        ctx.setStatus({
+            running: false,
+            lastStopAt: Date.now(),
+            ...accountRuntime.buildRuntimeStatus(),
+        });
+        ctx.log?.info(`[${account.accountId}] wecom runtime stopped`);
+    }
+}

package/dist/src/http.js

@@ -0,0 +1,114 @@
+import { ProxyAgent, fetch as undiciFetch } from "undici";
+const proxyDispatchers = new Map();
+/**
+ * **getProxyDispatcher (获取代理 Dispatcher)**
+ *
+ * 缓存并复用 ProxyAgent，避免重复创建连接池。
+ */
+function getProxyDispatcher(proxyUrl) {
+    const existing = proxyDispatchers.get(proxyUrl);
+    if (existing)
+        return existing;
+    const created = new ProxyAgent(proxyUrl);
+    proxyDispatchers.set(proxyUrl, created);
+    return created;
+}
+function summarizeHttpTarget(input) {
+    try {
+        const url = typeof input === "string" ? new URL(input) : input;
+        return `${url.origin}${url.pathname}`;
+    }
+    catch {
+        return String(input);
+    }
+}
+function mergeAbortSignal(params) {
+    const signals = [];
+    if (params.signal)
+        signals.push(params.signal);
+    if (params.timeoutMs && Number.isFinite(params.timeoutMs) && params.timeoutMs > 0) {
+        signals.push(AbortSignal.timeout(params.timeoutMs));
+    }
+    if (!signals.length)
+        return undefined;
+    if (signals.length === 1)
+        return signals[0];
+    return AbortSignal.any(signals);
+}
+/**
+ * **wecomFetch (统一 HTTP 请求)**
+ *
+ * 基于 `undici` 的 fetch 封装，自动处理 ProxyAgent 和 Timeout。
+ * 所有对企业微信 API 的调用都应经过此函数。
+ */
+export async function wecomFetch(input, init, opts) {
+    const proxyUrl = opts?.proxyUrl?.trim() ?? "";
+    const dispatcher = proxyUrl ? getProxyDispatcher(proxyUrl) : undefined;
+    const startedAt = Date.now();
+    const method = (init?.method ?? "GET").toUpperCase();
+    const target = summarizeHttpTarget(input);
+    const initSignal = init?.signal ?? undefined;
+    const signal = mergeAbortSignal({ signal: opts?.signal ?? initSignal, timeoutMs: opts?.timeoutMs });
+    const headers = new Headers(init?.headers ?? {});
+    if (!headers.has("User-Agent")) {
+        headers.set("User-Agent", "OpenClaw/2.0 (WeCom-Agent)");
+    }
+    const nextInit = {
+        ...(init ?? {}),
+        ...(signal ? { signal } : {}),
+        ...(dispatcher ? { dispatcher } : {}),
+        headers,
+    };
+    try {
+        console.log(`[wecom-http] request method=${method} target=${target} proxy=${proxyUrl || "none"} timeoutMs=${String(opts?.timeoutMs ?? "none")}`);
+        const response = await undiciFetch(input, nextInit);
+        console.log(`[wecom-http] response method=${method} target=${target} status=${response.status} durationMs=${Date.now() - startedAt}`);
+        return response;
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === "TimeoutError") {
+            console.error(`[wecom-http] timeout method=${method} target=${target} durationMs=${Date.now() - startedAt} proxy=${proxyUrl || "none"}`);
+        }
+        else if (err instanceof Error && err.name === "TypeError" && err.message === "fetch failed") {
+            const cause = err.cause;
+            console.error(`[wecom-http] fetch failed method=${method} target=${target} durationMs=${Date.now() - startedAt} proxy=${proxyUrl || "none"}${cause ? ` cause=${String(cause)}` : ""}`);
+        }
+        else if (err instanceof Error && err.name === "AbortError") {
+            console.error(`[wecom-http] aborted method=${method} target=${target} durationMs=${Date.now() - startedAt} proxy=${proxyUrl || "none"}`);
+        }
+        throw err;
+    }
+}
+/**
+ * **readResponseBodyAsBuffer (读取响应 Body)**
+ *
+ * 将 Response Body 读取为 Buffer，支持最大字节限制以防止内存溢出。
+ * 适用于下载媒体文件等场景。
+ */
+export async function readResponseBodyAsBuffer(res, maxBytes) {
+    if (!res.body)
+        return Buffer.alloc(0);
+    const limit = maxBytes && Number.isFinite(maxBytes) && maxBytes > 0 ? maxBytes : undefined;
+    const chunks = [];
+    let total = 0;
+    const reader = res.body.getReader();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        total += value.byteLength;
+        if (limit && total > limit) {
+            try {
+                await reader.cancel("body too large");
+            }
+            catch {
+                // ignore
+            }
+            throw new Error(`response body too large (>${limit} bytes)`);
+        }
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks.map((c) => Buffer.from(c)));
+}

package/{src/media.ts → dist/src/media.js}

@@ -1,56 +1,49 @@
 import crypto from "node:crypto";
 import { decodeEncodingAESKey, pkcs7Unpad, WECOM_PKCS7_BLOCK_SIZE } from "./crypto.js";
-import { readResponseBodyAsBuffer, wecomFetch, type WecomHttpOptions } from "./http.js";
-
-export type DecryptedWecomMedia = {
-    buffer: Buffer;
-    sourceContentType?: string;
-    sourceFilename?: string;
-    sourceUrl?: string;
-};
-
-function normalizeMime(contentType?: string | null): string | undefined {
+import { readResponseBodyAsBuffer, wecomFetch } from "./http.js";
+function normalizeMime(contentType) {
     const raw = String(contentType ?? "").trim();
-    if (!raw) return undefined;
+    if (!raw)
+        return undefined;
     return raw.split(";")[0]?.trim().toLowerCase() || undefined;
 }
-
-function extractFilenameFromContentDisposition(disposition?: string | null): string | undefined {
+function extractFilenameFromContentDisposition(disposition) {
     const raw = String(disposition ?? "").trim();
-    if (!raw) return undefined;
-
+    if (!raw)
+        return undefined;
     const star = raw.match(/filename\*\s*=\s*([^;]+)/i);
     if (star?.[1]) {
         const v = star[1].trim().replace(/^UTF-8''/i, "").replace(/^"(.*)"$/, "$1");
         try {
             const decoded = decodeURIComponent(v);
-            if (decoded.trim()) return decoded.trim();
-        } catch { /* ignore */ }
-        if (v.trim()) return v.trim();
+            if (decoded.trim())
+                return decoded.trim();
+        }
+        catch { /* ignore */ }
+        if (v.trim())
+            return v.trim();
     }
-
     const plain = raw.match(/filename\s*=\s*([^;]+)/i);
     if (plain?.[1]) {
         const v = plain[1].trim().replace(/^"(.*)"$/, "$1").trim();
-        if (v) return v;
+        if (v)
+            return v;
     }
     return undefined;
 }
-
 /**
  * **decryptWecomMedia (解密企业微信媒体文件)**
- * 
+ *
  * 简易封装：直接传入 URL 和 AES Key 下载并解密。
  * 企业微信媒体文件使用与消息体相同的 AES-256-CBC 加密，IV 为 AES Key 前16字节。
  * 解密后需移除 PKCS#7 填充。
  */
-export async function decryptWecomMedia(url: string, encodingAESKey: string, maxBytes?: number): Promise<Buffer> {
+export async function decryptWecomMedia(url, encodingAESKey, maxBytes) {
     return decryptWecomMediaWithHttp(url, encodingAESKey, { maxBytes });
 }
-
 /**
  * **decryptWecomMediaWithHttp (解密企业微信媒体 - 高级)**
- * 
+ *
  * 支持传递 HTTP 选项（如 Proxy、Timeout）。
  * 流程：
  * 1. 下载加密内容。
@@ -58,26 +51,17 @@ export async function decryptWecomMedia(url: string, encodingAESKey: string, max
  * 3. AES-CBC 解密。
  * 4. PKCS#7 去除填充。
  */
-export async function decryptWecomMediaWithHttp(
-    url: string,
-    encodingAESKey: string,
-    params?: { maxBytes?: number; http?: WecomHttpOptions },
-): Promise<Buffer> {
+export async function decryptWecomMediaWithHttp(url, encodingAESKey, params) {
     const decrypted = await decryptWecomMediaWithMeta(url, encodingAESKey, params);
     return decrypted.buffer;
 }
-
 /**
  * **decryptWecomMediaWithMeta (解密企业微信媒体并返回源信息)**
- * 
+ *
  * 在返回解密结果的同时，保留下载响应中的元信息（content-type / filename / final url），
  * 供上层更准确地推断文件后缀和 MIME。
  */
-export async function decryptWecomMediaWithMeta(
-    url: string,
-    encodingAESKey: string,
-    params?: { maxBytes?: number; http?: WecomHttpOptions },
-): Promise<DecryptedWecomMedia> {
+export async function decryptWecomMediaWithMeta(url, encodingAESKey, params) {
     // 1. Download encrypted content
     const res = await wecomFetch(url, undefined, { ...params?.http, timeoutMs: params?.http?.timeoutMs ?? 15_000 });
     if (!res.ok) {
@@ -87,11 +71,9 @@ export async function decryptWecomMediaWithMeta(
     const sourceFilename = extractFilenameFromContentDisposition(res.headers.get("content-disposition"));
     const sourceUrl = res.url || url;
     const encryptedData = await readResponseBodyAsBuffer(res, params?.maxBytes);
-
     // 2. Prepare Key and IV
     const aesKey = decodeEncodingAESKey(encodingAESKey);
     const iv = aesKey.subarray(0, 16);
-
     // 3. Decrypt
     const decipher = crypto.createDecipheriv("aes-256-cbc", aesKey, iv);
     decipher.setAutoPadding(false); // We handle padding manually
@@ -99,7 +81,6 @@ export async function decryptWecomMediaWithMeta(
         decipher.update(encryptedData),
         decipher.final(),
     ]);
-
     // 4. Unpad
     // Note: Unlike msg bodies, usually removing PKCS#7 padding is enough for media files.
     // The Python SDK logic: pad_len = decrypted_data[-1]; decrypted_data = decrypted_data[:-pad_len]

package/dist/src/monitor/limits.js

@@ -0,0 +1,7 @@
+export const LIMITS = {
+    STREAM_TTL_MS: 10 * 60 * 1000,
+    ACTIVE_REPLY_TTL_MS: 60 * 60 * 1000,
+    DEFAULT_DEBOUNCE_MS: 500,
+    STREAM_MAX_BYTES: 20_480,
+    REQUEST_TIMEOUT_MS: 15_000,
+};

package/dist/src/monitor/state.js

@@ -0,0 +1,28 @@
+import { LegacyOperationalEventStore } from "../observability/legacy-operational-event-store.js";
+import { ActiveReplyStore } from "../store/active-reply-store.js";
+import { StreamStore } from "../store/stream-batch-store.js";
+import { LIMITS } from "./limits.js";
+export { LIMITS, StreamStore, ActiveReplyStore };
+class MonitorState {
+    streamStore = new StreamStore();
+    activeReplyStore = new ActiveReplyStore("multi");
+    operationalEvents = new LegacyOperationalEventStore();
+    pruneInterval;
+    startPruning(intervalMs = 60_000) {
+        if (this.pruneInterval)
+            return;
+        this.pruneInterval = setInterval(() => {
+            const now = Date.now();
+            this.streamStore.prune(now);
+            this.activeReplyStore.prune(now);
+            this.operationalEvents.prune(now);
+        }, intervalMs);
+    }
+    stopPruning() {
+        if (this.pruneInterval) {
+            clearInterval(this.pruneInterval);
+            this.pruneInterval = undefined;
+        }
+    }
+}
+export const monitorState = new MonitorState();