@yanhaidao/wecom 2.3.4 → 2.3.9

package/src/config/derived-paths.ts

@@ -0,0 +1,41 @@
+import { DEFAULT_ACCOUNT_ID } from "./accounts.js";
+import type { WecomTransportKind } from "../types/runtime.js";
+import { WEBHOOK_PATHS } from "../types/constants.js";
+
+export function resolveDerivedPath(params: {
+  accountId: string;
+  transport: Extract<WecomTransportKind, "bot-webhook" | "agent-callback">;
+  includeLegacy?: boolean;
+}): string[] {
+  const accountId = params.accountId.trim() || DEFAULT_ACCOUNT_ID;
+  const isDefault = accountId === DEFAULT_ACCOUNT_ID;
+  if (params.transport === "bot-webhook") {
+    return isDefault
+      ? [
+          `${WEBHOOK_PATHS.BOT_PLUGIN}/${accountId}`,
+          `${WEBHOOK_PATHS.BOT}/${accountId}`,
+          WEBHOOK_PATHS.BOT_PLUGIN,
+          WEBHOOK_PATHS.BOT_ALT,
+          WEBHOOK_PATHS.BOT,
+        ]
+      : [`${WEBHOOK_PATHS.BOT_PLUGIN}/${accountId}`];
+  }
+  return isDefault
+    ? [
+        `${WEBHOOK_PATHS.AGENT_PLUGIN}/${accountId}`,
+        `${WEBHOOK_PATHS.AGENT}/${accountId}`,
+        WEBHOOK_PATHS.AGENT_PLUGIN,
+        WEBHOOK_PATHS.AGENT,
+      ]
+    : [`${WEBHOOK_PATHS.AGENT_PLUGIN}/${accountId}`];
+}
+
+export function resolveDerivedPathSummary(accountId: string): {
+  botWebhook: string[];
+  agentCallback: string[];
+} {
+  return {
+    botWebhook: resolveDerivedPath({ accountId, transport: "bot-webhook" }),
+    agentCallback: resolveDerivedPath({ accountId, transport: "agent-callback" }),
+  };
+}

package/src/config/index.ts

@@ -1,18 +1,16 @@
-/**
- * WeCom 配置模块导出
- */
-
 export { WecomConfigSchema, type WecomConfigInput } from "./schema.js";
 export {
-    DEFAULT_ACCOUNT_ID,
-    detectMode,
-    listWecomAccountIds,
-    resolveDefaultWecomAccountId,
-    resolveWecomAccount,
-    resolveWecomAccountConflict,
-    resolveWecomAccounts,
-    isWecomEnabled,
+  DEFAULT_ACCOUNT_ID,
+  detectMode,
+  listWecomAccountIds,
+  resolveDefaultWecomAccountId,
+  resolveWecomAccount,
+  resolveWecomAccountConflict,
+  resolveWecomAccounts,
+  isWecomEnabled,
 } from "./accounts.js";
+export { resolveWecomRuntimeAccount, resolveWecomRuntimeConfig, type ResolvedRuntimeAccount, type ResolvedRuntimeConfig } from "./runtime-config.js";
+export { resolveDerivedPath, resolveDerivedPathSummary } from "./derived-paths.js";
 export { resolveWecomEgressProxyUrl, resolveWecomEgressProxyUrlFromNetwork } from "./network.js";
 export { DEFAULT_WECOM_MEDIA_MAX_BYTES, resolveWecomMediaMaxBytes } from "./media.js";
 export { resolveWecomFailClosedOnDefaultRoute, shouldRejectWecomDefaultRoute } from "./routing.js";

package/src/config/runtime-config.ts

@@ -0,0 +1,46 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+
+import { resolveDerivedPathSummary } from "./derived-paths.js";
+import { DEFAULT_ACCOUNT_ID, resolveWecomAccount, resolveWecomAccounts } from "./accounts.js";
+import type { ResolvedWecomAccount, WecomConfig } from "../types/index.js";
+
+export type ResolvedRuntimeAccount = {
+  account: ResolvedWecomAccount;
+  derivedPaths: ReturnType<typeof resolveDerivedPathSummary>;
+};
+
+export type ResolvedRuntimeConfig = {
+  raw: WecomConfig | undefined;
+  defaultAccountId: string;
+  accounts: Record<string, ResolvedRuntimeAccount>;
+};
+
+export function resolveWecomRuntimeConfig(cfg: OpenClawConfig): ResolvedRuntimeConfig {
+  const raw = cfg.channels?.wecom as WecomConfig | undefined;
+  const resolved = resolveWecomAccounts(cfg);
+  const accounts = Object.fromEntries(
+    Object.entries(resolved.accounts).map(([accountId, account]) => [
+      accountId,
+      {
+        account,
+        derivedPaths: resolveDerivedPathSummary(accountId),
+      },
+    ]),
+  );
+  return {
+    raw,
+    defaultAccountId: resolved.defaultAccountId || DEFAULT_ACCOUNT_ID,
+    accounts,
+  };
+}
+
+export function resolveWecomRuntimeAccount(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): ResolvedRuntimeAccount {
+  const account = resolveWecomAccount(params);
+  return {
+    account,
+    derivedPaths: resolveDerivedPathSummary(account.accountId),
+  };
+}

package/src/config/schema.ts

@@ -1,143 +1,99 @@
-/**
- * WeCom 配置 Schema (Zod)
- */
-
 import { z } from "zod";
 
 function bindToJsonSchema<T extends z.ZodTypeAny>(schema: T): T {
-    const anySchema = schema as unknown as { toJSONSchema?: (...args: any[]) => unknown };
-    if (typeof anySchema.toJSONSchema === "function") {
-        anySchema.toJSONSchema = anySchema.toJSONSchema.bind(schema) as any;
-    }
-    return schema;
+  const schemaWithJson = schema as T & { toJSONSchema?: (...args: unknown[]) => unknown };
+  if (typeof schemaWithJson.toJSONSchema === "function") {
+    schemaWithJson.toJSONSchema = schemaWithJson.toJSONSchema.bind(schema);
+  }
+  return schema;
 }
 
-/**
- * **dmSchema (单聊配置)**
- * 
- * 控制单聊行为（如允许名单、策略）。
- * @property enabled - 是否启用单聊 [默认: true]
- * @property policy - 访问策略: "pairing" (需配对, 默认), "allowlist" (仅在名单), "open" (所有人), "disabled" (禁用)
- * @property allowFrom - 允许的用户ID或群ID列表 (仅当 policy="allowlist" 时生效)
- */
-const dmSchema = z.object({
-    enabled: z.boolean().optional(),
+const dmSchema = z
+  .object({
     policy: z.enum(["pairing", "allowlist", "open", "disabled"]).optional(),
     allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-}).optional();
+  })
+  .optional();
 
-/**
- * **mediaSchema (媒体处理配置)**
- * 
- * 控制媒体文件的下载和缓存行为。
- * @property tempDir - 临时文件下载目录
- * @property retentionHours - 临时文件保留时间（小时）
- * @property cleanupOnStart - 启动时是否自动清理旧文件
- * @property maxBytes - 允许下载的最大字节数
- */
-const mediaSchema = z.object({
+const mediaSchema = z
+  .object({
     tempDir: z.string().optional(),
     retentionHours: z.number().optional(),
     cleanupOnStart: z.boolean().optional(),
     maxBytes: z.number().optional(),
-}).optional();
+  })
+  .optional();
 
-/**
- * **networkSchema (网络配置)**
- * 
- * 控制 HTTP 请求行为，特别是出站代理。
- * @property timeoutMs - 请求超时时间 (毫秒)
- * @property retries - 重试次数
- * @property retryDelayMs - 重试间隔 (毫秒)
- * @property egressProxyUrl - 出站 HTTP 代理 (如 "http://127.0.0.1:7890")
- */
-const networkSchema = z.object({
-    timeoutMs: z.number().optional(),
-    retries: z.number().optional(),
-    retryDelayMs: z.number().optional(),
+const networkSchema = z
+  .object({
     egressProxyUrl: z.string().optional(),
-}).optional();
+  })
+  .optional();
 
-/**
- * **routingSchema (路由策略配置)**
- *
- * 控制未命中 bindings 时的回退行为。
- * @property failClosedOnDefaultRoute - true=拒绝 default 回退，false=允许回退默认 agent
- */
-const routingSchema = z.object({
+const routingSchema = z
+  .object({
     failClosedOnDefaultRoute: z.boolean().optional(),
-}).optional();
+  })
+  .optional();
 
-/**
- * **botSchema (Bot 模式配置)**
- * 
- * 用于配置企业微信内部机器人 (Webhook 模式)。
- * @property token - 企业微信后台设置的 Token
- * @property encodingAESKey - 企业微信后台设置的 EncodingAESKey
- * @property receiveId - (可选) 接收者ID，通常不用填
- * @property streamPlaceholderContent - (可选) 流式响应中的占位符，默认为 "Thinking..."或空
- * @property welcomeText - (可选) 用户首次对话时的欢迎语
- * @property dm - 单聊策略覆盖配置
- */
-const botSchema = z.object({
-    aibotid: z.string().optional(),
+const botWsSchema = z
+  .object({
+    botId: z.string(),
+    secret: z.string(),
+  })
+  .optional();
+
+const botWebhookSchema = z
+  .object({
     token: z.string(),
     encodingAESKey: z.string(),
-    botIds: z.array(z.string()).optional(),
     receiveId: z.string().optional(),
+  })
+  .optional();
+
+const botSchema = z
+  .object({
+    primaryTransport: z.enum(["ws", "webhook"]).optional(),
     streamPlaceholderContent: z.string().optional(),
     welcomeText: z.string().optional(),
     dm: dmSchema,
-}).optional();
+    aibotid: z.string().optional(),
+    botIds: z.array(z.string()).optional(),
+    ws: botWsSchema,
+    webhook: botWebhookSchema,
+  })
+  .optional();
 
-/**
- * **agentSchema (Agent 模式配置)**
- * 
- * 用于配置企业微信自建应用 (Agent)。
- * @property corpId - 企业 ID (CorpID)
- * @property corpSecret - 应用 Secret
- * @property agentId - 应用 AgentId (数字，可选)
- * @property token - 回调配置 Token
- * @property encodingAESKey - 回调配置 EncodingAESKey
- * @property welcomeText - (可选) 欢迎语
- * @property dm - 单聊策略覆盖配置
- */
-const agentSchema = z.object({
+const agentSchema = z
+  .object({
     corpId: z.string(),
     corpSecret: z.string(),
-    agentId: z.union([z.string(), z.number()]).optional(),
+    agentId: z.union([z.number(), z.string()]).optional(),
     token: z.string(),
     encodingAESKey: z.string(),
     welcomeText: z.string().optional(),
     dm: dmSchema,
-}).optional();
+  })
+  .optional();
 
-/**
- * **dynamicAgentsSchema (动态 Agent 配置)**
- *
- * 控制是否按用户/群组自动创建独立 Agent 实例。
- * @property enabled - 是否启用动态 Agent
- * @property dmCreateAgent - 私聊是否为每个用户创建独立 Agent
- * @property groupEnabled - 群聊是否启用动态 Agent
- * @property adminUsers - 管理员列表（绕过动态路由）
- */
-const dynamicAgentsSchema = z.object({
+const dynamicAgentsSchema = z
+  .object({
     enabled: z.boolean().optional(),
     dmCreateAgent: z.boolean().optional(),
     groupEnabled: z.boolean().optional(),
     adminUsers: z.array(z.string()).optional(),
-}).optional();
+  })
+  .optional();
 
-/** Matrix 账号条目 */
 const accountSchema = z.object({
-    enabled: z.boolean().optional(),
-    name: z.string().optional(),
-    bot: botSchema,
-    agent: agentSchema,
+  enabled: z.boolean().optional(),
+  name: z.string().optional(),
+  bot: botSchema,
+  agent: agentSchema,
 });
 
-/** 顶层 WeCom 配置 Schema */
-export const WecomConfigSchema = bindToJsonSchema(z.object({
+export const WecomConfigSchema = bindToJsonSchema(
+  z.object({
     enabled: z.boolean().optional(),
     bot: botSchema,
     agent: agentSchema,
@@ -147,6 +103,7 @@ export const WecomConfigSchema = bindToJsonSchema(z.object({
     network: networkSchema,
     routing: routingSchema,
     dynamicAgents: dynamicAgentsSchema,
-}));
+  }),
+);
 
 export type WecomConfigInput = z.infer<typeof WecomConfigSchema>;

package/src/domain/models.ts

@@ -0,0 +1,7 @@
+import type { DeliveryTask, RawFrameReference, ReplyContext, TransportSessionSnapshot, UnifiedInboundEvent } from "../types/index.js";
+
+export type WecomConversation = UnifiedInboundEvent["conversation"];
+export type WecomRawEnvelope = RawFrameReference;
+export type WecomReplyContext = ReplyContext;
+export type WecomTransportSession = TransportSessionSnapshot;
+export type WecomDeliveryTask = DeliveryTask;

package/src/domain/policies.ts

@@ -0,0 +1,36 @@
+import type { ResolvedBotAccount, UnifiedInboundEvent } from "../types/index.js";
+
+export function assertBotPrimaryTransport(account: ResolvedBotAccount): void {
+  if (account.primaryTransport === "ws" && !account.wsConfigured) {
+    throw new Error(`WeCom bot account "${account.accountId}" is missing bot.ws credentials.`);
+  }
+  if (account.primaryTransport === "webhook" && !account.webhookConfigured) {
+    throw new Error(`WeCom bot account "${account.accountId}" is missing bot.webhook credentials.`);
+  }
+}
+
+export function buildDedupKey(event: UnifiedInboundEvent): string {
+  return `${event.accountId}:${event.transport}:${event.messageId}`;
+}
+
+export function resolveConversationKey(event: UnifiedInboundEvent): string {
+  const conversation = event.conversation;
+  return [event.accountId, conversation.peerKind, conversation.peerId, conversation.senderId].join(":");
+}
+
+export function normalizeWecomAllowFromEntry(raw: string): string {
+  return raw
+    .trim()
+    .toLowerCase()
+    .replace(/^wecom:/, "")
+    .replace(/^user:/, "")
+    .replace(/^userid:/, "");
+}
+
+export function isWecomSenderAllowed(senderUserId: string, allowFrom: string[]): boolean {
+  const list = allowFrom.map((entry) => normalizeWecomAllowFromEntry(entry)).filter(Boolean);
+  if (list.includes("*")) return true;
+  const normalizedSender = normalizeWecomAllowFromEntry(senderUserId);
+  if (!normalizedSender) return false;
+  return list.includes(normalizedSender);
+}

package/src/dynamic-agent.ts

@@ -48,6 +48,12 @@ export function generateAgentId(chatType: "dm" | "group", peerId: string, accoun
     return `wecom-${sanitizedAccountId}-${chatType}-${sanitizedPeer}`;
 }
 
+export function buildAgentSessionTarget(userId: string, accountId?: string): string {
+    const normalizedUserId = String(userId).trim();
+    const sanitizedAccountId = sanitizeDynamicIdPart(accountId ?? "default") || "default";
+    return `wecom-agent:${sanitizedAccountId}:${normalizedUserId}`;
+}
+
 /**
  * **shouldUseDynamicAgent (检查是否使用动态 Agent)**
  *

package/src/gateway-monitor.ts

@@ -1,18 +1,20 @@
 import type {
   ChannelGatewayContext,
   OpenClawConfig,
-  PluginRuntime,
 } from "openclaw/plugin-sdk";
 
 import {
-  detectMode,
   listWecomAccountIds,
+  resolveDerivedPathSummary,
   resolveWecomAccount,
   resolveWecomAccountConflict,
 } from "./config/index.js";
-import { registerAgentWebhookTarget, registerWecomWebhookTarget } from "./monitor.js";
+import { createAccountRuntime } from "./app/bootstrap.js";
+import { registerAccountRuntime, unregisterAccountRuntime } from "./app/index.js";
 import type { ResolvedWecomAccount, WecomConfig } from "./types/index.js";
-import { WEBHOOK_PATHS } from "./types/constants.js";
+import { WecomBotCapabilityService } from "./capability/bot/index.js";
+import { WecomAgentIngressService } from "./capability/agent/index.js";
+import type { WecomRuntimeEnv } from "./types/runtime-context.js";
 
 type AccountRouteRegistryItem = {
   botPaths: string[];
@@ -75,30 +77,6 @@ function waitForAbortSignal(abortSignal: AbortSignal): Promise<void> {
   });
 }
 
-function uniquePaths(paths: string[]): string[] {
-  return Array.from(new Set(paths.map((path) => path.trim()).filter(Boolean)));
-}
-
-function resolveBotRegistrationPaths(params: { accountId: string; matrixMode: boolean }): string[] {
-  if (params.matrixMode) {
-    return uniquePaths([
-      `${WEBHOOK_PATHS.BOT_PLUGIN}/${params.accountId}`,
-      `${WEBHOOK_PATHS.BOT_ALT}/${params.accountId}`,
-    ]);
-  }
-  return uniquePaths([WEBHOOK_PATHS.BOT_PLUGIN, WEBHOOK_PATHS.BOT, WEBHOOK_PATHS.BOT_ALT]);
-}
-
-function resolveAgentRegistrationPaths(params: { accountId: string; matrixMode: boolean }): string[] {
-  if (params.matrixMode) {
-    return uniquePaths([
-      `${WEBHOOK_PATHS.AGENT_PLUGIN}/${params.accountId}`,
-      `${WEBHOOK_PATHS.AGENT}/${params.accountId}`,
-    ]);
-  }
-  return uniquePaths([WEBHOOK_PATHS.AGENT_PLUGIN, WEBHOOK_PATHS.AGENT]);
-}
-
 /**
  * Keeps WeCom webhook targets registered for the account lifecycle.
  * The promise only settles after gateway abort/reload signals shutdown.
@@ -122,29 +100,11 @@ export async function monitorWecomProvider(
     });
     throw new Error(conflict.message);
   }
-  const mode = detectMode(cfg.channels?.wecom as WecomConfig | undefined);
-  const matrixMode = mode === "matrix";
   const bot = account.bot;
   const agent = account.agent;
   const botConfigured = Boolean(bot?.configured);
   const agentConfigured = Boolean(agent?.configured);
 
-  if (mode === "legacy" && (botConfigured || agentConfigured)) {
-    if (agentConfigured && !botConfigured) {
-      ctx.log?.warn(
-        `[${account.accountId}] 检测到仍在使用单 Agent 兼容模式。建议尽快升级为多账号模式：` +
-        `将 channels.wecom.agent 迁移到 channels.wecom.accounts.<accountId>.agent，` +
-        `并设置 channels.wecom.defaultAccount。`,
-      );
-    } else {
-      ctx.log?.warn(
-        `[${account.accountId}] 检测到仍在使用单账号兼容模式。建议尽快升级为多账号模式：` +
-        `将 channels.wecom.bot/agent 迁移到 channels.wecom.accounts.<accountId>.bot/agent，` +
-        `并设置 channels.wecom.defaultAccount。`,
-      );
-    }
-  }
-
   if (!botConfigured && !agentConfigured) {
     ctx.log?.warn(`[${account.accountId}] wecom not configured; channel is idle`);
     ctx.setStatus({ accountId: account.accountId, running: false, configured: false });
@@ -152,50 +112,38 @@ export async function monitorWecomProvider(
     return;
   }
 
-  const unregisters: Array<() => void> = [];
+  const accountRuntime = createAccountRuntime(ctx);
+  registerAccountRuntime(accountRuntime);
   const botPaths: string[] = [];
   const agentPaths: string[] = [];
+  const runtimeEnv: WecomRuntimeEnv = {
+    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 {
-    if (bot && botConfigured) {
-      const paths = resolveBotRegistrationPaths({
-        accountId: account.accountId,
-        matrixMode,
-      });
-      for (const path of paths) {
-        unregisters.push(
-          registerWecomWebhookTarget({
-            account: bot,
-            config: cfg,
-            runtime: ctx.runtime,
-            // The HTTP handler resolves the active PluginRuntime via getWecomRuntime().
-            // The stored target only needs to be decrypt/verify-capable.
-            core: {} as PluginRuntime,
-            path,
-            statusSink: (patch) => ctx.setStatus({ accountId: ctx.accountId, ...patch }),
-          }),
-        );
-      }
-      botPaths.push(...paths);
-      ctx.log?.info(`[${account.accountId}] wecom bot webhook registered at ${paths.join(", ")}`);
+    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(", ")}`,
+      );
     }
 
-    if (agent && agentConfigured) {
-      const paths = resolveAgentRegistrationPaths({
-        accountId: account.accountId,
-        matrixMode,
-      });
-      for (const path of paths) {
-        unregisters.push(
-          registerAgentWebhookTarget({
-            agent,
-            config: cfg,
-            runtime: ctx.runtime,
-            path,
-          }),
-        );
-      }
-      agentPaths.push(...paths);
-      ctx.log?.info(`[${account.accountId}] wecom agent webhook registered at ${paths.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 });
@@ -207,25 +155,27 @@ export async function monitorWecomProvider(
     }
 
     ctx.setStatus({
-      accountId: account.accountId,
       running: true,
       configured: true,
-      webhookPath: botConfigured
-        ? (botPaths[0] ?? WEBHOOK_PATHS.BOT_PLUGIN)
-        : (agentPaths[0] ?? WEBHOOK_PATHS.AGENT_PLUGIN),
+      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 {
-    for (const unregister of unregisters) {
-      unregister();
-    }
+    botService.stop();
+    agentIngress.stop();
     accountRouteRegistry.delete(account.accountId);
+    unregisterAccountRuntime(account.accountId);
     ctx.setStatus({
-      accountId: account.accountId,
       running: false,
       lastStopAt: Date.now(),
+      ...accountRuntime.buildRuntimeStatus(),
     });
+    ctx.log?.info(`[${account.accountId}] wecom runtime stopped`);
   }
 }

package/src/http.ts

@@ -18,6 +18,15 @@ function getProxyDispatcher(proxyUrl: string): ProxyDispatcher {
   return created;
 }
 
+function summarizeHttpTarget(input: string | URL): string {
+  try {
+    const url = typeof input === "string" ? new URL(input) : input;
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    return String(input);
+  }
+}
+
 function mergeAbortSignal(params: {
   signal?: AbortSignal;
   timeoutMs?: number;
@@ -54,6 +63,9 @@ export type WecomHttpOptions = {
 export async function wecomFetch(input: string | URL, init?: RequestInit, opts?: WecomHttpOptions): Promise<Response> {
   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 });
@@ -71,11 +83,20 @@ export async function wecomFetch(input: string | URL, init?: RequestInit, opts?:
   };
 
   try {
-    return await undiciFetch(input, nextInit as Parameters<typeof undiciFetch>[1]) as unknown as Response;
+    console.log(
+      `[wecom-http] request method=${method} target=${target} proxy=${proxyUrl || "none"} timeoutMs=${String(opts?.timeoutMs ?? "none")}`,
+    );
+    const response = await undiciFetch(input, nextInit as Parameters<typeof undiciFetch>[1]) as unknown as Response;
+    console.log(
+      `[wecom-http] response method=${method} target=${target} status=${response.status} durationMs=${Date.now() - startedAt}`,
+    );
+    return response;
   } catch (err: unknown) {
     if (err instanceof Error && err.name === "TypeError" && err.message === "fetch failed") {
       const cause = (err as any).cause;
-      console.error(`[wecom-http] fetch failed: ${input} (proxy: ${proxyUrl || "none"})${cause ? ` - cause: ${String(cause)}` : ""}`);
+      console.error(
+        `[wecom-http] fetch failed method=${method} target=${target} durationMs=${Date.now() - startedAt} proxy=${proxyUrl || "none"}${cause ? ` cause=${String(cause)}` : ""}`,
+      );
     }
     throw err;
   }

package/src/monitor/limits.ts

@@ -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,
+};