@yanhaidao/wecom 2.4.120 → 2.5.110

package/src/capability/bot/stream-orchestrator.ts

@@ -1,371 +0,0 @@
-import { pathToFileURL } from "node:url";
-
-import type { PluginRuntime } from "openclaw/plugin-sdk";
-
-import { resolveWecomMediaMaxBytes, shouldRejectWecomDefaultRoute } from "../../config/index.js";
-import { ensureDynamicAgentListed, generateAgentId, shouldUseDynamicAgent } from "../../dynamic-agent.js";
-import { LIMITS, type StreamStore } from "../../monitor/state.js";
-import { getWecomRuntime } from "../../runtime.js";
-import { buildWecomUnauthorizedCommandPrompt, resolveWecomCommandAuthorization } from "../../shared/command-auth.js";
-import type { PendingInbound } from "../../types/legacy-stream.js";
-import type { WecomBotInboundMessage as WecomInboundMessage } from "../../types/index.js";
-import type { WecomWebhookTarget } from "../../types/runtime-context.js";
-import { looksLikeSendLocalFileIntent, processBotInboundMessage } from "../../transport/bot-webhook/inbound-normalizer.js";
-import { resolveWecomSenderUserId } from "../../transport/bot-webhook/message-shape.js";
-import { buildWecomBotDispatchConfig } from "./dispatch-config.js";
-import { sendBotFallbackPromptNow } from "./fallback-delivery.js";
-import { finalizeBotStream } from "./stream-finalizer.js";
-import { handleDirectLocalPathIntent } from "./local-path-delivery.js";
-import { stageWecomInboundMediaForSession } from "./sandbox-media.js";
-import { createBotReplyDispatcher } from "./stream-delivery.js";
-import type { BotRuntimeLogger, RecordBotOperationalEvent } from "./types.js";
-
-export type StartBotAgentStreamParams = {
-  target: WecomWebhookTarget;
-  accountId: string;
-  msg: WecomInboundMessage;
-  streamId: string;
-  mergedContents?: string[] | string;
-  mergedMsgids?: string[];
-};
-
-export function createBotStreamOrchestrator(params: {
-  streamStore: StreamStore;
-  recordBotOperationalEvent: RecordBotOperationalEvent;
-}) {
-  const { streamStore, recordBotOperationalEvent } = params;
-
-  const logVerbose: BotRuntimeLogger = (target, message) => {
-    const should =
-      target.core.logging?.shouldLogVerbose?.() ??
-      (() => {
-        try {
-          return getWecomRuntime().logging.shouldLogVerbose();
-        } catch {
-          return false;
-        }
-      })();
-    if (!should) return;
-    target.runtime.log?.(`[wecom] ${message}`);
-  };
-
-  const logInfo: BotRuntimeLogger = (target, message) => {
-    target.runtime.log?.(`[wecom] ${message}`);
-  };
-
-  const truncateUtf8Bytes = (text: string, maxBytes: number): string => {
-    const buf = Buffer.from(text, "utf8");
-    if (buf.length <= maxBytes) return text;
-    return buf.subarray(buf.length - maxBytes).toString("utf8");
-  };
-
-  const computeTaskKey = (target: WecomWebhookTarget, msg: WecomInboundMessage): string | undefined => {
-    const msgid = msg.msgid ? String(msg.msgid) : "";
-    if (!msgid) return undefined;
-    const aibotid = String((msg as any).aibotid ?? "unknown").trim() || "unknown";
-    return `bot:${target.account.accountId}:${aibotid}:${msgid}`;
-  };
-
-  async function flushPending(pending: PendingInbound): Promise<void> {
-    const { streamId, target, msg, contents, msgids, conversationKey, batchKey } = pending;
-    const mergedContents = contents.filter((c) => c.trim()).join("\n").trim();
-
-    let core: PluginRuntime | null = null;
-    try {
-      core = getWecomRuntime();
-    } catch (err) {
-      logVerbose(target, `flush pending: runtime not ready: ${String(err)}`);
-      streamStore.markFinished(streamId);
-      logInfo(target, `queue: runtime not ready，结束批次并推进 streamId=${streamId}`);
-      streamStore.onStreamFinished(streamId);
-      return;
-    }
-
-    if (!core) return;
-
-    streamStore.markStarted(streamId);
-    const enrichedTarget: WecomWebhookTarget = { ...target, core };
-    logInfo(
-      target,
-      `flush pending: start batch streamId=${streamId} batchKey=${batchKey} conversationKey=${conversationKey} mergedCount=${contents.length}`,
-    );
-    logVerbose(target, `防抖结束: 开始处理聚合消息 数量=${contents.length} streamId=${streamId}`);
-
-    startAgentForStream({
-      target: enrichedTarget,
-      accountId: target.account.accountId,
-      msg,
-      streamId,
-      mergedContents: contents.length > 1 ? mergedContents : undefined,
-      mergedMsgids: msgids.length > 1 ? msgids : undefined,
-    }).catch((err) => {
-      streamStore.updateStream(streamId, (state) => {
-        state.error = err instanceof Error ? err.message : String(err);
-        state.content = state.content || `Error: ${state.error}`;
-        state.finished = true;
-      });
-      target.runtime.error?.(`[${target.account.accountId}] wecom agent failed (处理失败): ${String(err)}`);
-      streamStore.onStreamFinished(streamId);
-    });
-  }
-
-  async function startAgentForStream(params: StartBotAgentStreamParams): Promise<void> {
-    const { target, msg, streamId } = params;
-    const core = target.core;
-    const config = target.config;
-    const account = target.account;
-
-    const userId = resolveWecomSenderUserId(msg) || "unknown";
-    const chatType = msg.chattype === "group" ? "group" : "direct";
-    const chatId = msg.chattype === "group" ? (msg.chatid?.trim() || "unknown") : userId;
-    const taskKey = computeTaskKey(target, msg);
-    const aibotid = String((msg as any).aibotid ?? "").trim() || undefined;
-
-    streamStore.updateStream(streamId, (s) => {
-      s.userId = userId;
-      s.chatType = chatType;
-      s.chatId = chatId;
-      s.taskKey = taskKey;
-      s.aibotid = aibotid;
-    });
-
-    let { body: rawBody, media } = await processBotInboundMessage({
-      target,
-      msg,
-      recordOperationalIssue: (event) => recordBotOperationalEvent(target, event),
-    });
-
-    if (params.mergedContents) {
-      rawBody = Array.isArray(params.mergedContents) ? params.mergedContents.join("\n") : params.mergedContents;
-    }
-
-    const handledLocalPath = await handleDirectLocalPathIntent({
-      streamStore,
-      target,
-      streamId,
-      rawBody,
-      userId,
-      chatType,
-      logVerbose,
-      looksLikeSendLocalFileIntent,
-    });
-    if (handledLocalPath) return;
-
-    let mediaPath: string | undefined;
-    let mediaType: string | undefined;
-    const mediaFilename = media?.filename;
-    if (media) {
-      try {
-        const maxBytes = resolveWecomMediaMaxBytes(target.config, target.account.accountId);
-        const saved = await core.channel.media.saveMediaBuffer(media.buffer, media.contentType, "inbound", maxBytes, media.filename);
-        mediaPath = saved.path;
-        mediaType = saved.contentType;
-        logVerbose(target, `saved inbound media to ${mediaPath} (${mediaType})`);
-      } catch (err) {
-        target.runtime.error?.(`Failed to save inbound media: ${String(err)}`);
-      }
-    }
-
-    const route = core.channel.routing.resolveAgentRoute({
-      cfg: config,
-      channel: "wecom",
-      accountId: account.accountId,
-      peer: { kind: chatType === "group" ? "group" : "direct", id: chatId },
-    });
-
-    const useDynamicAgent = shouldUseDynamicAgent({
-      chatType: chatType === "group" ? "group" : "dm",
-      senderId: userId,
-      config,
-    });
-
-    if (shouldRejectWecomDefaultRoute({ cfg: config, matchedBy: route.matchedBy, useDynamicAgent })) {
-      const prompt =
-        `当前账号（${account.accountId}）未绑定 OpenClaw Agent，已拒绝回退到默认主智能体。` +
-        `请在 bindings 中添加：{"agentId":"你的Agent","match":{"channel":"wecom","accountId":"${account.accountId}"}}`;
-      target.runtime.error?.(
-        `[wecom] routing guard: blocked default fallback accountId=${account.accountId} matchedBy=${route.matchedBy} streamId=${streamId}`,
-      );
-      streamStore.updateStream(streamId, (s) => {
-        s.finished = true;
-        s.content = prompt;
-      });
-      try {
-        await sendBotFallbackPromptNow({ streamId, text: prompt });
-      } catch (err) {
-        target.runtime.error?.(`routing guard prompt push failed streamId=${streamId}: ${String(err)}`);
-      }
-      streamStore.onStreamFinished(streamId);
-      return;
-    }
-
-    if (useDynamicAgent) {
-      const targetAgentId = generateAgentId(chatType === "group" ? "group" : "dm", chatId, account.accountId);
-      route.agentId = targetAgentId;
-      route.sessionKey = `agent:${targetAgentId}:wecom:${account.accountId}:${chatType === "group" ? "group" : "dm"}:${chatId}`;
-      ensureDynamicAgentListed(targetAgentId, core).catch(() => { });
-      logVerbose(target, `dynamic agent routing: ${targetAgentId}, sessionKey=${route.sessionKey}`);
-    }
-
-    if (mediaPath) {
-      try {
-        const stagedSessionPath = await stageWecomInboundMediaForSession({
-          cfg: target.config,
-          accountId: target.account.accountId,
-          agentId: route.agentId,
-          sessionKey: route.sessionKey,
-          mediaPath,
-          filename: mediaFilename,
-        });
-        mediaPath = stagedSessionPath;
-        logVerbose(target, `session media staged to ${mediaPath}`);
-      } catch (err) {
-        target.runtime.error?.(`Failed to stage inbound media for session workspace: ${String(err)}`);
-      }
-    }
-
-    logVerbose(target, `starting agent processing (streamId=${streamId}, agentId=${route.agentId}, peerKind=${chatType}, peerId=${chatId})`);
-    logVerbose(target, `启动 Agent 处理: streamId=${streamId} 路由=${route.agentId} 类型=${chatType} ID=${chatId}`);
-
-    const fromLabel = chatType === "group" ? `group:${chatId}` : `user:${userId}`;
-    const storePath = core.channel.session.resolveStorePath(config.session?.store, { agentId: route.agentId });
-    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(config);
-    const previousTimestamp = core.channel.session.readSessionUpdatedAt({
-      storePath,
-      sessionKey: route.sessionKey,
-    });
-    const body = core.channel.reply.formatAgentEnvelope({
-      channel: "WeCom",
-      from: fromLabel,
-      previousTimestamp,
-      envelope: envelopeOptions,
-      body: rawBody,
-    });
-
-    const authz = await resolveWecomCommandAuthorization({
-      core,
-      cfg: config,
-      accountConfig: account.config,
-      rawBody,
-      senderUserId: userId,
-    });
-    const commandAuthorized = authz.commandAuthorized;
-    logVerbose(
-      target,
-      `authz: dmPolicy=${authz.dmPolicy} shouldCompute=${authz.shouldComputeAuth} sender=${userId.toLowerCase()} senderAllowed=${authz.senderAllowed} authorizerConfigured=${authz.authorizerConfigured} commandAuthorized=${String(authz.commandAuthorized)}`,
-    );
-
-    if (authz.shouldComputeAuth && authz.commandAuthorized !== true) {
-      const prompt = buildWecomUnauthorizedCommandPrompt({ senderUserId: userId, dmPolicy: authz.dmPolicy, scope: "bot" });
-      streamStore.updateStream(streamId, (s) => {
-        s.finished = true;
-        s.content = prompt;
-      });
-      try {
-        await sendBotFallbackPromptNow({ streamId, text: prompt });
-        logInfo(target, `authz: 未授权命令已提示用户 streamId=${streamId}`);
-      } catch (err) {
-        target.runtime.error?.(`authz: 未授权命令提示推送失败 streamId=${streamId}: ${String(err)}`);
-      }
-      streamStore.onStreamFinished(streamId);
-      return;
-    }
-
-    const attachments = mediaPath
-      ? [
-        {
-          name: media?.filename || "file",
-          mimeType: mediaType,
-          url: pathToFileURL(mediaPath).href,
-        },
-      ]
-      : undefined;
-
-    const ctxPayload = core.channel.reply.finalizeInboundContext({
-      Body: body,
-      RawBody: rawBody,
-      CommandBody: rawBody,
-      Attachments: attachments,
-      From: chatType === "group" ? `wecom:group:${chatId}` : `wecom:user:${userId}`,
-      To: chatType === "group" ? `wecom:group:${chatId}` : `wecom:user:${chatId}`,
-      SessionKey: route.sessionKey,
-      AccountId: route.accountId,
-      ChatType: chatType,
-      ConversationLabel: fromLabel,
-      SenderName: userId,
-      SenderId: userId,
-      Provider: "wecom",
-      Surface: "wecom",
-      MessageSid: msg.msgid,
-      CommandAuthorized: commandAuthorized,
-      OriginatingChannel: "wecom",
-      OriginatingTo: chatType === "group" ? `wecom:group:${chatId}` : `wecom:user:${chatId}`,
-      MediaPath: mediaPath,
-      MediaType: mediaType,
-      MediaUrl: mediaPath,
-    });
-
-    await core.channel.session.recordInboundSession({
-      storePath,
-      sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
-      ctx: ctxPayload,
-      onRecordError: (err) => {
-        target.runtime.error?.(`wecom: failed updating session meta: ${String(err)}`);
-      },
-    });
-
-    const tableMode = core.channel.text.resolveMarkdownTableMode({
-      cfg: config,
-      channel: "wecom",
-      accountId: account.accountId,
-    });
-    const cfgForDispatch = buildWecomBotDispatchConfig(config);
-    logVerbose(target, "tool-policy: WeCom Bot 会话已禁用 message 工具（tools.deny += message；并同步到 tools.sandbox.tools.deny，防止绕过 Bot 交付）");
-
-    await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-      ctx: ctxPayload,
-      cfg: cfgForDispatch,
-      replyOptions: { disableBlockStreaming: false },
-      dispatcherOptions: createBotReplyDispatcher({
-        streamStore,
-        target,
-        accountId: account.accountId,
-        config,
-        msg,
-        streamId,
-        rawBody,
-        chatType,
-        userId,
-        core,
-        tableMode,
-        logVerbose,
-        truncateUtf8Bytes,
-        recordBotOperationalEvent,
-      }),
-    });
-
-    const rawBodyNormalized = rawBody.trim();
-    const isResetCommand = /^\/(new|reset)(?:\s|$)/i.test(rawBodyNormalized);
-    const resetCommandKind = isResetCommand ? (rawBodyNormalized.match(/^\/(new|reset)/i)?.[1]?.toLowerCase() ?? "new") : null;
-
-    await finalizeBotStream({
-      streamStore,
-      target,
-      streamId,
-      chatType,
-      core,
-      config,
-      accountId: account.accountId,
-      isResetCommand,
-      resetCommandKind,
-      logInfo,
-      logVerbose,
-      recordBotOperationalEvent,
-    });
-  }
-
-  return {
-    flushPending,
-    startAgentForStream,
-  };
-}

package/src/capability/bot/types.ts

@@ -1,8 +0,0 @@
-import type { WecomRuntimeAuditEvent, WecomWebhookTarget } from "../../types/runtime-context.js";
-
-export type BotRuntimeLogger = (target: WecomWebhookTarget, message: string) => void;
-
-export type RecordBotOperationalEvent = (
-  target: Pick<WecomWebhookTarget, "account" | "auditSink">,
-  event: Omit<WecomRuntimeAuditEvent, "transport">,
-) => void;

package/src/capability/calendar/SKILLS_CHECKLIST.md

@@ -1,251 +0,0 @@
-# WeCom Calendar Skills 技能清单
-
-## 技能列表
-
-### wecom_calendar - 企业微信日历工具
-
-**技能 ID**: `wecom_calendar`  
-**标签**: `WeCom Calendar`  
-**描述**: 企业微信日历工具。支持创建/更新/删除日历和日程，管理日程参与者，获取日历详情等功能。
-
-## 支持的 Actions (13 个)
-
-### 日历管理 (4 个)
-
-#### 1. calendar_create - 创建日历
-**参数**:
-- `summary` (必填): 日历标题，1-128 字符
-- `color` (必填): RGB 颜色编码，如 #FF3030
-- `description` (可选): 日历描述，0-512 字符
-- `admins` (可选): 日历管理员 userid 列表，最多 3 人
-- `set_as_default` (可选): 是否设为默认日历，0-否，1-是（第三方应用不支持）
-- `shares` (可选): 通知范围成员列表，最多 2000 人
-- `is_public` (可选): 是否公共日历，0-否，1-是
-- `public_range` (可选): 公开范围
-  - `userids`: 公开的成员列表，最多 1000 个
-  - `partyids`: 公开的部门列表，最多 100 个
-- `is_corp_calendar` (可选): 是否全员日历，0-否，1-是
-
-**返回**: `{ ok: true, action: "calendar_create", calId: string, raw: object }`
-
-#### 2. calendar_update - 更新日历
-**参数**:
-- `cal_id` (必填): 日历 ID
-- `summary` (必填): 日历标题，1-128 字符
-- `color` (必填): RGB 颜色编码
-- `description` (可选): 日历描述，0-512 字符
-- `admins` (可选): 日历管理员，最多 3 人
-- `shares` (可选): 通知范围成员，最多 2000 人
-- `public_range` (可选): 公开范围
-- `skip_public_range` (可选): 是否不更新可订阅范围，0-否，1-是
-
-**返回**: `{ ok: true, action: "calendar_update", calId: string, raw: object }`
-
-#### 3. calendar_get - 获取日历详情
-**参数**:
-- `cal_id_list` (必填): 日历 ID 列表，一次最多 1000 条
-
-**返回**: `{ ok: true, action: "calendar_get", calendarList: array, raw: object }`
-
-#### 4. calendar_delete - 删除日历
-**参数**:
-- `cal_id` (必填): 日历 ID
-
-**返回**: `{ ok: true, action: "calendar_delete", calId: string, raw: object }`
-
-### 日程管理 (7 个)
-
-#### 5. schedule_create - 创建日程
-**参数**:
-- `start_time` (必填): 日程开始时间，Unix 时间戳（秒）
-- `end_time` (必填): 日程结束时间，Unix 时间戳（秒）
-- `is_whole_day` (可选): 是否全天日程，0-否，1-是
-- `summary` (可选): 日程标题，0-128 字符
-- `description` (可选): 日程描述，不多于 1000 字符
-- `location` (可选): 日程地址，不多于 128 字符
-- `attendees` (可选): 日程参与者列表，最多 1000 人
-- `admins` (可选): 日程管理员，最多 3 人
-- `reminders` (可选): 提醒相关信息
-  - `is_remind`: 是否需要提醒，0-否，1-是
-  - `is_repeat`: 是否重复日程，0-否，1-是
-  - `remind_before_event_secs`: 日程开始前多少秒提醒 [0,300,900,3600,86400]
-  - `remind_time_diffs`: 提醒时间与日程开始时间的差值数组
-  - `repeat_type`: 重复类型 [0-每日，1-每周，2-每月，5-每年，7-工作日]
-  - `repeat_until`: 重复结束时刻，Unix 时间戳
-  - `is_custom_repeat`: 是否自定义重复，0-否，1-是
-  - `repeat_interval`: 重复间隔
-  - `repeat_day_of_week`: 每周周几重复 [1-7]
-  - `repeat_day_of_month`: 每月哪几天重复 [1-31]
-  - `timezone`: 时区 [-12 到 +12]
-- `cal_id` (可选): 日程所属日历 ID（第三方应用必须指定）
-
-**返回**: `{ ok: true, action: "schedule_create", scheduleId: string, raw: object }`
-
-#### 6. schedule_update - 更新日程
-**参数**:
-- `schedule_id` (必填): 日程 ID
-- `start_time` (必填): 日程开始时间
-- `end_time` (必填): 日程结束时间
-- `is_whole_day` (可选): 是否全天日程
-- `summary` (可选): 日程标题
-- `description` (可选): 日程描述
-- `location` (可选): 日程地址
-- `attendees` (可选): 日程参与者
-- `admins` (可选): 日程管理员
-- `reminders` (可选): 提醒相关信息
-- `skip_attendees` (可选): 是否不更新参与人，0-否，1-是
-- `op_mode` (可选): 操作模式 [0-全部修改，1-仅修改此日程，2-修改将来的所有日程]
-- `op_start_time` (可选): 操作起始时间
-
-**返回**: `{ ok: true, action: "schedule_update", scheduleId: string, raw: object }`
-
-#### 7. schedule_add_attendees - 新增日程参与者
-**参数**:
-- `schedule_id` (必填): 日程 ID
-- `attendees` (必填): 日程参与者列表，累计最多 1000 人
-
-**返回**: `{ ok: true, action: "schedule_add_attendees", scheduleId: string, raw: object }`
-
-#### 8. schedule_del_attendees - 删除日程参与者
-**参数**:
-- `schedule_id` (必填): 日程 ID
-- `attendees` (必填): 日程参与者列表，最多 1000 人
-
-**返回**: `{ ok: true, action: "schedule_del_attendees", scheduleId: string, raw: object }`
-
-#### 9. schedule_get_by_calendar - 获取日历下的日程列表
-**参数**:
-- `cal_id` (必填): 日历 ID
-- `offset` (可选): 分页偏移量，默认 0
-- `limit` (可选): 分页大小，默认 500，范围 1-1000
-
-**返回**: `{ ok: true, action: "schedule_get_by_calendar", scheduleList: array, raw: object }`
-
-#### 10. schedule_get - 获取日程详情
-**参数**:
-- `schedule_id_list` (必填): 日程 ID 列表，一次最多 1000 条
-
-**返回**: `{ ok: true, action: "schedule_get", scheduleList: array, meetingCode: string, meetingLink: string, raw: object }`
-
-#### 11. schedule_delete - 取消日程
-**参数**:
-- `schedule_id` (必填): 日程 ID
-- `op_mode` (可选): 操作模式 [0-删除所有，1-仅删除此日程，2-删除本次及后续]
-- `op_start_time` (可选): 操作起始时间
-
-**返回**: `{ ok: true, action: "schedule_delete", scheduleId: string, raw: object }`
-
-### 默认日历管理 (2 个)
-
-#### 12. schedule_get_system_calid - 获取默认日历本 ID
-**参数**:
-- `userid` (必填): 指定成员的 userid
-
-**返回**: `{ ok: true, action: "schedule_get_system_calid", calId: string, raw: object }`
-
-#### 13. schedule_create_in_system - 在默认日历创建日程
-**参数**:
-- `organizer` (必填): 日程创建者 userid
-- `start_time` (必填): 日程开始时间
-- `end_time` (必填): 日程结束时间
-- `is_whole_day` (可选): 是否全天日程
-- `summary` (可选): 日程标题
-- `description` (可选): 日程描述
-- `location` (可选): 日程地址
-- `attendees` (可选): 日程参与者
-- `reminders` (可选): 提醒相关信息
-
-**返回**: `{ ok: true, action: "schedule_create_in_system", scheduleId: string, raw: object }`
-
-## 与官方文档对比验证
-
-### 接口完整性 ✓
-- [x] 创建日历 (calendar/add) - 完整实现
-- [x] 更新日历 (calendar/update) - 完整实现
-- [x] 获取日历 (calendar/get) - 完整实现
-- [x] 删除日历 (calendar/del) - 完整实现
-- [x] 创建日程 (schedule/add) - 完整实现
-- [x] 更新日程 (schedule/update) - 完整实现
-- [x] 新增参与者 (schedule/add_attendees) - 完整实现
-- [x] 删除参与者 (schedule/del_attendees) - 完整实现
-- [x] 获取日程列表 (schedule/get_by_calendar) - 完整实现
-- [x] 获取日程详情 (schedule/get) - 完整实现
-- [x] 取消日程 (schedule/del) - 完整实现
-- [x] 获取默认日历 ID (calendar/get_system_calid) - 完整实现
-- [x] 创建默认日历日程 (schedule/add_schedule_in_system_cal) - 完整实现
-- [x] 更新日程回执 (schedule/respond) - 已实现（client.ts）
-- [x] 同步日程 (schedule/sync) - 已实现（client.ts）
-
-### 参数验证 ✓
-- [x] 所有必填参数都有 required 声明
-- [x] 所有参数的类型、格式、取值范围都正确
-- [x] 所有接口限制都有验证（数量、字符）
-- [x] 所有枚举值都正确定义
-
-### 返回值处理 ✓
-- [x] 所有接口返回结果结构正确
-- [x] 错误处理完善（HTTP 错误、JSON 错误、业务错误）
-- [x] 重试机制实现（3 次）
-
-### 特殊功能 ✓
-- [x] op_mode 操作模式支持（0/1/2）
-- [x] op_start_time 重复日程操作
-- [x] 提醒时间枚举值验证
-- [x] 时区范围验证（-12 到 +12）
-- [x] 重复日程自定义设置
-
-## 已知限制和注意事项
-
-1. **第三方应用**：不支持 `set_as_default` 参数
-2. **全员日历**：每个企业最多 20 个，不支持指定颜色
-3. **公共日历**：每人最多创建或订阅 100 个
-4. **日程数量**：每个应用每天最多 2 万个
-5. **重复日程修改**：需指定 op_mode 和 op_start_time
-6. **会议室关联**：已预约会议室的日程更新时间受限
-
-## 待实现功能
-
-1. **回调事件处理** - 需要在 webhook 中添加以下事件处理：
-   - delete_calendar
-   - modify_calendar
-   - modify_schedule
-   - delete_schedule
-   - respond_schedule
-   - add_schedule
-
-2. **完整实现** - client.ts 和 tool.ts 需要完善所有方法的具体实现
-
-## 使用示例
-
-```json
-// 创建日历
-{
-  "action": "calendar_create",
-  "summary": "团队日历",
-  "color": "#FF3030",
-  "description": "团队共享日历",
-  "admins": ["zhangsan", "lisi"],
-  "shares": [{"userid": "wangwu", "permission": 1}]
-}
-
-// 创建日程
-{
-  "action": "schedule_create",
-  "start_time": 1679011200,
-  "end_time": 1679014800,
-  "summary": "项目评审会议",
-  "location": "10 楼会议室",
-  "attendees": [{"userid": "user1"}, {"userid": "user2"}],
-  "reminders": {
-    "is_remind": 1,
-    "remind_before_event_secs": 3600,
-    "timezone": 8
-  }
-}
-
-// 获取日程详情
-{
-  "action": "schedule_get",
-  "schedule_id_list": ["schedule_id_1", "schedule_id_2"]
-}
-```