@yanhaidao/wecom 2.3.150 → 2.3.180

package/src/capability/doc/types.ts

@@ -85,10 +85,10 @@ export interface Spacing {
 }
 
 export enum LineSpacingRule {
+    UNSPECIFIED = "LINE_SPACING_RULE_UNSPECIFIED",
     AUTO = "LINE_SPACING_RULE_AUTO",
     EXACT = "LINE_SPACING_RULE_EXACT",
-    AT_LEAST = "LINE_SPACING_RULE_AT_LEAST",
-    UNSPECIFIED = "PAGE_ORIENTATION_UNSPECIFIED" // Note: User text had a copy-paste error here, listing PAGE_ORIENTATION_UNSPECIFIED
+    AT_LEAST = "LINE_SPACING_RULE_AT_LEAST"
 }
 
 export interface Indent {
@@ -330,7 +330,7 @@ export interface Range {
 
 export interface ReplaceTextRequest {
     text: string;
-    ranges: Range[];
+    ranges: Range[];  // 最多 10 个范围
 }
 
 export interface InsertTextRequest {
@@ -365,13 +365,7 @@ export interface InsertParagraphRequest {
 
 export interface TextProperty {
     bold?: boolean;
-    italics?: boolean; // User text says "italics", Schema says "italic". User text for RunProperty says "italics", UpdateTextProperty example says "bold" but doesn't list italics explicitly in example, but RunProperty does. Standard WeCom API is "italics"? My schema says "italic". I will use "italics" as per user provided text for RunProperty, but UpdateTextProperty might differ.
-    // User text for TextProperty example: bold, color, background_color.
-    // RunProperty has "italics".
-    // I will check the user provided TextProperty definition again.
-    // "blod" (typo in user text), color, background_color.
-    // It doesn't list italics in TextProperty section, but RunProperty does.
-    // I will support what is likely correct.
+    italics?: boolean;
     underline?: boolean;
     strikethrough?: boolean;
     color?: string;
@@ -381,7 +375,7 @@ export interface TextProperty {
 
 export interface UpdateTextPropertyRequest {
     text_property: TextProperty;
-    ranges: Range[];
+    ranges: Range[];  // 最多 10 个范围
 }
 
 export interface UpdateRequest {
@@ -398,6 +392,15 @@ export interface UpdateRequest {
 export interface BatchUpdateDocResponse {
     errcode: number;
     errmsg: string;
+    responses?: Array<{
+        insert_text_response?: { end_location: Location };
+        delete_content_response?: { end_location: Location };
+        replace_text_response?: { occurances: number };
+        insert_image_response?: { image_id: string };
+        insert_table_response?: { table_id: string };
+        insert_paragraph_response?: { paragraph_id: string };
+        update_text_property_response?: Record<string, never>;
+    }>;
 }
 
 export interface GetDocContentResponse {
@@ -412,20 +415,20 @@ export interface GetDocContentResponse {
 export interface FormQuestionOption {
     key: number;           // 必填，选项 key 从 1 开始
     value: string;         // 必填，选项内容
-    status?: number;       // 1 正常，2 删除
+    status?: number;       // 1 正常，2 删除。创建时不传则自动填充为 1
 }
 
 export interface FormQuestion {
     question_id: number;                           // 必填，问题 ID 从 1 开始（家校从 2 开始）
     title: string;                                 // 必填，问题标题
     pos: number;                                   // 必填，问题序号从 1 开始
-    status?: number;                               // 1 正常，2 删除
+    status?: number;                               // 1 正常，2 删除。创建时不传则自动填充为 1
     reply_type: number;                            // 必填，问题类型（1-22）
     must_reply: boolean;                           // 必填，是否必答
     note?: string;                                 // 可选，备注
     placeholder?: string;                          // 可选，输入提示
     question_extend_setting?: FormQuestionExtendSetting;  // 可选，题型扩展设置
-    option_item?: FormQuestionOption[];            // 单选/多选/下拉列表必填
+    option_item?: FormQuestionOption[];            // 单选/多选/下拉列表必填，创建时不传 status 则自动填充为 1
 }
 
 export interface FormQuestionExtendSetting {
@@ -674,3 +677,116 @@ export interface GetSheetRangeDataResponse {
         result: GridData;
     };
 }
+
+// --- Smart Table Records & Fields Types ---
+
+export interface SmartTableRecord {
+    record_id: string;
+    create_time?: string;
+    update_time?: string;
+    values: Record<string, any>;
+    creator_name?: string;
+    updater_name?: string;
+}
+
+export interface SmartTableGetRecordsResponse {
+    errcode: number;
+    errmsg: string;
+    records?: SmartTableRecord[];
+    total?: number;
+    has_more?: boolean;
+    next?: number;
+    ver?: number;
+}
+
+export interface SmartTableField {
+    field_id: string;
+    field_title: string;
+    field_type: string;
+    property_number?: any;
+    property_checkbox?: any;
+    property_date_time?: any;
+    property_attachment?: any;
+    property_user?: any;
+    property_url?: any;
+    property_select?: any;
+    property_created_time?: any;
+    property_modified_time?: any;
+    property_progress?: any;
+    property_single_select?: any;
+    property_reference?: any;
+    property_location?: any;
+    property_auto_number?: any;
+    property_currency?: any;
+    property_ww_group?: any;
+    property_percentage?: any;
+    property_barcode?: any;
+    property_image?: any;
+    property_phone_number?: any;
+    property_email?: any;
+}
+
+export interface SmartTableGetFieldsResponse {
+    errcode: number;
+    errmsg: string;
+    fields?: SmartTableField[];
+    total?: number;
+    has_more?: boolean;
+    next?: number;
+}
+
+export interface SmartTableView {
+    view_id: string;
+    view_title: string;
+    view_type: string;
+    is_visible?: boolean;
+    type?: string;
+    property?: any;
+}
+
+export interface SmartTableGetViewsResponse {
+    errcode: number;
+    errmsg: string;
+    views?: SmartTableView[];
+    total?: number;
+    has_more?: boolean;
+    next?: number;
+}
+
+export interface SmartTableFieldGroup {
+    field_group_id: string;
+    name: string;
+    children?: { field_id: string }[];
+}
+
+export interface SmartTableGetGroupsResponse {
+    errcode: number;
+    errmsg: string;
+    field_groups?: SmartTableFieldGroup[];
+    total?: number;
+    has_more?: boolean;
+    next?: number;
+}
+
+export interface SmartTableSheetPriv {
+    sheet_id: string;
+    priv: number;
+    can_insert_record?: boolean;
+    can_delete_record?: boolean;
+    can_create_modify_delete_view?: boolean;
+    field_priv?: any;
+    record_priv?: any;
+    clear?: boolean;
+}
+
+export interface SmartTableGetSheetPrivResponse {
+    errcode: number;
+    errmsg: string;
+    rule_list?: any[];
+}
+
+export interface SmartTableCreateRuleResponse {
+    errcode: number;
+    errmsg: string;
+    rule_id?: number;
+}

package/src/capability/mcp/index.ts

@@ -0,0 +1,10 @@
+export { createWeComMcpToolFactory } from "./tool.js";
+export {
+  clearWecomMcpAccountCache,
+  clearWecomMcpCategoryCache,
+  McpHttpError,
+  McpRpcError,
+  sendJsonRpc,
+  type McpToolInfo,
+} from "./transport.js";
+export { cleanSchemaForGemini } from "./schema.js";

package/src/capability/mcp/schema.ts

@@ -0,0 +1,107 @@
+const GEMINI_UNSUPPORTED_KEYWORDS = new Set([
+  "patternProperties",
+  "additionalProperties",
+  "$schema",
+  "$id",
+  "$ref",
+  "$defs",
+  "definitions",
+  "examples",
+  "minLength",
+  "maxLength",
+  "minimum",
+  "maximum",
+  "multipleOf",
+  "pattern",
+  "format",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "minProperties",
+  "maxProperties",
+]);
+
+export function cleanSchemaForGemini(schema: unknown): unknown {
+  if (!schema || typeof schema !== "object") return schema;
+  if (Array.isArray(schema)) return schema.map(cleanSchemaForGemini);
+
+  const obj = schema as Record<string, unknown>;
+  const defs: Record<string, unknown> = {
+    ...(obj.$defs && typeof obj.$defs === "object" ? (obj.$defs as Record<string, unknown>) : {}),
+    ...(obj.definitions && typeof obj.definitions === "object"
+      ? (obj.definitions as Record<string, unknown>)
+      : {}),
+  };
+  return cleanWithDefs(obj, defs, new Set());
+}
+
+function cleanWithDefs(
+  schema: unknown,
+  defs: Record<string, unknown>,
+  refStack: Set<string>,
+): unknown {
+  if (!schema || typeof schema !== "object") return schema;
+  if (Array.isArray(schema)) return schema.map((item) => cleanWithDefs(item, defs, refStack));
+
+  const obj = schema as Record<string, unknown>;
+  if (obj.$defs && typeof obj.$defs === "object") {
+    Object.assign(defs, obj.$defs as Record<string, unknown>);
+  }
+  if (obj.definitions && typeof obj.definitions === "object") {
+    Object.assign(defs, obj.definitions as Record<string, unknown>);
+  }
+
+  if (typeof obj.$ref === "string") {
+    const ref = obj.$ref;
+    if (refStack.has(ref)) return {};
+    const match = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
+    if (match?.[1] && defs[match[1]]) {
+      const nextStack = new Set(refStack);
+      nextStack.add(ref);
+      return cleanWithDefs(defs[match[1]], defs, nextStack);
+    }
+    return {};
+  }
+
+  const cleaned: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (GEMINI_UNSUPPORTED_KEYWORDS.has(key)) continue;
+    if (key === "const") {
+      cleaned.enum = [value];
+      continue;
+    }
+    if (key === "properties" && value && typeof value === "object" && !Array.isArray(value)) {
+      cleaned[key] = Object.fromEntries(
+        Object.entries(value as Record<string, unknown>).map(([propKey, propValue]) => [
+          propKey,
+          cleanWithDefs(propValue, defs, refStack),
+        ]),
+      );
+      continue;
+    }
+    if (key === "items" && value) {
+      cleaned[key] = Array.isArray(value)
+        ? value.map((item) => cleanWithDefs(item, defs, refStack))
+        : cleanWithDefs(value, defs, refStack);
+      continue;
+    }
+    if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
+      const nonNull = value.filter((variant) => {
+        if (!variant || typeof variant !== "object") return true;
+        return (variant as Record<string, unknown>).type !== "null";
+      });
+      if (nonNull.length === 1) {
+        const single = cleanWithDefs(nonNull[0], defs, refStack);
+        if (single && typeof single === "object" && !Array.isArray(single)) {
+          Object.assign(cleaned, single as Record<string, unknown>);
+        }
+      } else {
+        cleaned[key] = nonNull.map((variant) => cleanWithDefs(variant, defs, refStack));
+      }
+      continue;
+    }
+    cleaned[key] = value;
+  }
+
+  return cleaned;
+}

package/src/capability/mcp/tool.ts

@@ -0,0 +1,170 @@
+import type { OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { resolveWecomSourceSnapshot } from "../../runtime/source-registry.js";
+import { cleanSchemaForGemini } from "./schema.js";
+import { clearWecomMcpCategoryCache, sendJsonRpc, type McpToolInfo } from "./transport.js";
+
+type WecomMcpParams = {
+  action: "list" | "call";
+  category: string;
+  method?: string;
+  args?: string | Record<string, unknown>;
+};
+
+const BIZ_CACHE_CLEAR_ERROR_CODES = new Set([850002]);
+
+function textResult(data: unknown) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
+  };
+}
+
+function errorResult(error: unknown) {
+  if (error && typeof error === "object" && "errcode" in error) {
+    const errcode = Number((error as { errcode?: number }).errcode ?? 0);
+    const errmsg = String((error as { errmsg?: string }).errmsg ?? `错误码: ${errcode}`);
+    return textResult({ error: errmsg, errcode });
+  }
+  return textResult({
+    error: error instanceof Error ? error.message : String(error),
+  });
+}
+
+function parseArgs(args: string | Record<string, unknown> | undefined): Record<string, unknown> {
+  if (!args) return {};
+  if (typeof args === "object") return args;
+  try {
+    return JSON.parse(args) as Record<string, unknown>;
+  } catch (error) {
+    const detail = error instanceof SyntaxError ? error.message : String(error);
+    throw new Error(`args 不是合法的 JSON: ${args} (${detail})`);
+  }
+}
+
+function extractToolAccountId(ctx: OpenClawPluginToolContext): string | undefined {
+  const explicit = String((ctx as { accountId?: string }).accountId ?? "").trim();
+  if (explicit) return explicit;
+  const agentAccountId = String(ctx.agentAccountId ?? "").trim();
+  return agentAccountId || undefined;
+}
+
+async function handleList(accountId: string, category: string): Promise<unknown> {
+  const result = (await sendJsonRpc(accountId, category, "tools/list")) as
+    | { tools?: McpToolInfo[] }
+    | undefined;
+  const tools = result?.tools ?? [];
+  return {
+    accountId,
+    category,
+    count: tools.length,
+    tools: tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description ?? "",
+      inputSchema: tool.inputSchema ? cleanSchemaForGemini(tool.inputSchema) : undefined,
+    })),
+  };
+}
+
+function checkBizErrorAndClearCache(result: unknown, accountId: string, category: string): void {
+  if (!result || typeof result !== "object") return;
+  const content = (result as { content?: Array<{ type: string; text?: string }> }).content;
+  if (!Array.isArray(content)) return;
+  for (const item of content) {
+    if (item.type !== "text" || !item.text) continue;
+    try {
+      const parsed = JSON.parse(item.text) as { errcode?: number };
+      if (typeof parsed.errcode === "number" && BIZ_CACHE_CLEAR_ERROR_CODES.has(parsed.errcode)) {
+        clearWecomMcpCategoryCache(accountId, category);
+        return;
+      }
+    } catch {
+      // Ignore non-JSON content.
+    }
+  }
+}
+
+async function handleCall(
+  accountId: string,
+  category: string,
+  method: string,
+  args: Record<string, unknown>,
+): Promise<unknown> {
+  const result = await sendJsonRpc(accountId, category, "tools/call", {
+    name: method,
+    arguments: args,
+  });
+  checkBizErrorAndClearCache(result, accountId, category);
+  return result;
+}
+
+export function createWeComMcpToolFactory() {
+  return (toolContext: OpenClawPluginToolContext) => {
+    if (toolContext.messageChannel !== "wecom") {
+      return null;
+    }
+    const accountId = extractToolAccountId(toolContext);
+    const source = resolveWecomSourceSnapshot({
+      accountId,
+      sessionKey: toolContext.sessionKey,
+      sessionId: toolContext.sessionId,
+    });
+    if (!source || source.source !== "bot-ws") {
+      return null;
+    }
+
+    return {
+      name: "wecom_mcp",
+      label: "WeCom MCP",
+      description:
+        "企业微信 Bot WS MCP 工具。仅在 WeCom Bot WS 会话中可用，用于列出和调用企业微信 MCP 能力。",
+      parameters: {
+        type: "object" as const,
+        properties: {
+          action: {
+            type: "string",
+            enum: ["list", "call"],
+            description: "操作类型：list 或 call",
+          },
+          category: {
+            type: "string",
+            description: "MCP 品类，如 contact、todo、meeting、doc",
+          },
+          method: {
+            type: "string",
+            description: "action=call 时要调用的工具方法名",
+          },
+          args: {
+            type: "string",
+            description: "action=call 时传入的 JSON 字符串参数，默认 {}",
+          },
+        },
+        required: ["action", "category"],
+      },
+      async execute(_toolCallId: string, rawParams: unknown) {
+        try {
+          const params = rawParams as WecomMcpParams;
+          const effectiveAccountId = extractToolAccountId(toolContext);
+          if (!effectiveAccountId) {
+            throw new Error("当前会话缺少 WeCom accountId，无法调用 wecom_mcp。");
+          }
+
+          if (params.action === "list") {
+            return textResult(await handleList(effectiveAccountId, params.category));
+          }
+          if (!params.method) {
+            return textResult({ error: "action=call 时必须提供 method" });
+          }
+          return textResult(
+            await handleCall(
+              effectiveAccountId,
+              params.category,
+              params.method,
+              parseArgs(params.args),
+            ),
+          );
+        } catch (error) {
+          return errorResult(error);
+        }
+      },
+    };
+  };
+}