cc-lark 0.1.1

package/src/tools/chat/chat.ts

@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * feishu_chat tool - Manage Feishu chats/groups.
+ *
+ * Actions: search, get
+ */
+
+import { z } from 'zod';
+import type { ToolRegistry } from '../index.js';
+import { LarkClient } from '../../core/lark-client.js';
+import { getValidAccessToken, NeedAuthorizationError } from '../../core/uat-client.js';
+import { assertLarkOk } from '../../core/api-error.js';
+import { json, jsonError, type ToolResult } from '../im/helpers.js';
+import { logger } from '../../utils/logger.js';
+
+const log = logger('tools:chat:chat');
+
+// Schemas
+const searchActionSchema = {
+  action: z.literal('search').describe('Search for chats'),
+  query: z.string().describe('Search query (matches group name or member name)'),
+  page_size: z.number().min(1).optional().describe('Page size (default 20)'),
+  page_token: z.string().optional().describe('Pagination token'),
+};
+
+const getActionSchema = {
+  action: z.literal('get').describe('Get chat info'),
+  chat_id: z.string().describe('Chat ID (format: oc_xxx)'),
+};
+
+async function getAccessToken(context: { larkClient: LarkClient | null; config: import('../../core/types.js').FeishuConfig }): Promise<string | ToolResult> {
+  const { larkClient, config } = context;
+  if (!larkClient) return jsonError('LarkClient not initialized.');
+  const { appId, appSecret, brand } = config;
+  if (!appId || !appSecret) return jsonError('Missing FEISHU_APP_ID or FEISHU_APP_SECRET.');
+
+  const { listStoredTokens } = await import('../../core/token-store.js');
+  const tokens = await listStoredTokens(appId);
+  if (tokens.length === 0) return jsonError('No user authorization found.');
+  const userOpenId = tokens[0].userOpenId;
+
+  try {
+    return await getValidAccessToken({ userOpenId, appId, appSecret, domain: brand ?? 'feishu' });
+  } catch (err) {
+    if (err instanceof NeedAuthorizationError) return jsonError('User authorization expired.');
+    throw err;
+  }
+}
+
+export function registerChatTool(registry: ToolRegistry): void {
+  // Search chats
+  registry.register({
+    name: 'feishu_chat_search',
+    description: 'Search for Feishu chats by name or member.\n\nRequires OAuth authorization.',
+    inputSchema: searchActionSchema,
+    handler: async (args, context) => {
+      const p = args as z.infer<ReturnType<typeof z.object<typeof searchActionSchema>>>;
+      const { larkClient } = context;
+
+      const tokenResult = await getAccessToken(context);
+      if (typeof tokenResult === 'object' && 'content' in tokenResult) return tokenResult;
+      const accessToken = tokenResult;
+
+      log.info(`search: query="${p.query}", page_size=${p.page_size ?? 20}`);
+
+      const Lark = await import('@larksuiteoapi/node-sdk');
+      const opts = Lark.withUserAccessToken(accessToken);
+
+      const res = await larkClient!.sdk.im.v1.chat.search(
+        {
+          params: {
+            user_id_type: 'open_id',
+            query: p.query,
+            page_size: p.page_size,
+            page_token: p.page_token,
+          },
+        },
+        opts
+      );
+      assertLarkOk(res);
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const data = res.data as any;
+
+      return json({
+        items: data?.items,
+        has_more: data?.has_more ?? false,
+        page_token: data?.page_token,
+      });
+    },
+  });
+
+  // Get chat info
+  registry.register({
+    name: 'feishu_chat_get',
+    description: 'Get Feishu chat info by ID.\n\nRequires OAuth authorization.',
+    inputSchema: getActionSchema,
+    handler: async (args, context) => {
+      const p = args as z.infer<ReturnType<typeof z.object<typeof getActionSchema>>>;
+      const { larkClient } = context;
+
+      const tokenResult = await getAccessToken(context);
+      if (typeof tokenResult === 'object' && 'content' in tokenResult) return tokenResult;
+      const accessToken = tokenResult;
+
+      log.info(`get: chat_id=${p.chat_id}`);
+
+      const Lark = await import('@larksuiteoapi/node-sdk');
+      const opts = Lark.withUserAccessToken(accessToken);
+
+      const res = await larkClient!.sdk.im.v1.chat.get(
+        {
+          path: { chat_id: p.chat_id },
+          params: { user_id_type: 'open_id' },
+        },
+        opts
+      );
+      assertLarkOk(res);
+
+      return json({ chat: res.data });
+    },
+  });
+
+  log.debug('feishu_chat tools registered');
+}

package/src/tools/chat/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Chat Tools Index
+ *
+ * Chat/group management tools for Feishu/Lark.
+ */
+
+import type { ToolRegistry } from '../index.js';
+import { registerChatTool } from './chat.js';
+import { registerChatMembersTool } from './members.js';
+import { logger } from '../../utils/logger.js';
+
+const log = logger('tools:chat');
+
+export function registerChatTools(registry: ToolRegistry): void {
+  registerChatTool(registry);
+  registerChatMembersTool(registry);
+
+  log.info('Chat tools registered', {
+    tools: ['feishu_chat_search', 'feishu_chat_get', 'feishu_chat_members'].join(', '),
+  });
+}

package/src/tools/chat/members.ts

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * feishu_chat_members tool - Get chat members.
+ */
+
+import { z } from 'zod';
+import type { ToolRegistry } from '../index.js';
+import { LarkClient } from '../../core/lark-client.js';
+import { getValidAccessToken, NeedAuthorizationError } from '../../core/uat-client.js';
+import { assertLarkOk } from '../../core/api-error.js';
+import { json, jsonError, type ToolResult } from '../im/helpers.js';
+import { logger } from '../../utils/logger.js';
+
+const log = logger('tools:chat:members');
+
+// Schemas
+const membersActionSchema = {
+  chat_id: z.string().describe('Chat ID (format: oc_xxx)'),
+  member_id_type: z.enum(['open_id', 'union_id', 'user_id']).optional().describe('Member ID type (default: open_id)'),
+  page_size: z.number().min(1).optional().describe('Page size (default 20)'),
+  page_token: z.string().optional().describe('Pagination token'),
+};
+
+async function getAccessToken(context: { larkClient: LarkClient | null; config: import('../../core/types.js').FeishuConfig }): Promise<string | ToolResult> {
+  const { larkClient, config } = context;
+  if (!larkClient) return jsonError('LarkClient not initialized.');
+  const { appId, appSecret, brand } = config;
+  if (!appId || !appSecret) return jsonError('Missing FEISHU_APP_ID or FEISHU_APP_SECRET.');
+
+  const { listStoredTokens } = await import('../../core/token-store.js');
+  const tokens = await listStoredTokens(appId);
+  if (tokens.length === 0) return jsonError('No user authorization found.');
+  const userOpenId = tokens[0].userOpenId;
+
+  try {
+    return await getValidAccessToken({ userOpenId, appId, appSecret, domain: brand ?? 'feishu' });
+  } catch (err) {
+    if (err instanceof NeedAuthorizationError) return jsonError('User authorization expired.');
+    throw err;
+  }
+}
+
+export function registerChatMembersTool(registry: ToolRegistry): void {
+  registry.register({
+    name: 'feishu_chat_members',
+    description: 'Get members of a Feishu chat.\n\nRequires OAuth authorization.',
+    inputSchema: membersActionSchema,
+    handler: async (args, context) => {
+      const p = args as z.infer<ReturnType<typeof z.object<typeof membersActionSchema>>>;
+      const { larkClient } = context;
+
+      const tokenResult = await getAccessToken(context);
+      if (typeof tokenResult === 'object' && 'content' in tokenResult) return tokenResult;
+      const accessToken = tokenResult;
+
+      log.info(`members: chat_id="${p.chat_id}", page_size=${p.page_size ?? 20}`);
+
+      const Lark = await import('@larksuiteoapi/node-sdk');
+      const opts = Lark.withUserAccessToken(accessToken);
+
+      const res = await larkClient!.sdk.im.v1.chatMembers.get(
+        {
+          path: { chat_id: p.chat_id },
+          params: {
+            member_id_type: p.member_id_type || 'open_id',
+            page_size: p.page_size,
+            page_token: p.page_token,
+          },
+        },
+        opts
+      );
+      assertLarkOk(res);
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const data = res.data as any;
+      const memberCount = data?.items?.length ?? 0;
+      const memberTotal = data?.member_total ?? 0;
+
+      log.info(`members: found ${memberCount} members (total: ${memberTotal})`);
+
+      return json({
+        items: data?.items,
+        has_more: data?.has_more ?? false,
+        page_token: data?.page_token,
+        member_total: memberTotal,
+      });
+    },
+  });
+
+  log.debug('feishu_chat_members tool registered');
+}

package/src/tools/common/get-user.ts

@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * feishu_get_user tool - Get user information.
+ *
+ * Actions: get current user or get user by ID
+ */
+
+import { z } from 'zod';
+import type { ToolRegistry } from '../index.js';
+import { LarkClient } from '../../core/lark-client.js';
+import { getValidAccessToken, NeedAuthorizationError } from '../../core/uat-client.js';
+import { json, jsonError, type ToolResult } from '../im/helpers.js';
+import { logger } from '../../utils/logger.js';
+
+const log = logger('tools:common:get-user');
+
+// Schemas
+const getUserSchema = {
+  user_id: z.string().optional().describe('User ID (format: ou_xxx). If not provided, returns current user info'),
+  user_id_type: z.enum(['open_id', 'union_id', 'user_id']).optional().describe('User ID type (default: open_id)'),
+};
+
+async function getAccessToken(context: { larkClient: LarkClient | null; config: import('../../core/types.js').FeishuConfig }): Promise<string | ToolResult> {
+  const { larkClient, config } = context;
+  if (!larkClient) return jsonError('LarkClient not initialized.');
+  const { appId, appSecret, brand } = config;
+  if (!appId || !appSecret) return jsonError('Missing FEISHU_APP_ID or FEISHU_APP_SECRET.');
+
+  const { listStoredTokens } = await import('../../core/token-store.js');
+  const tokens = await listStoredTokens(appId);
+  if (tokens.length === 0) return jsonError('No user authorization found.');
+  const userOpenId = tokens[0].userOpenId;
+
+  try {
+    return await getValidAccessToken({ userOpenId, appId, appSecret, domain: brand ?? 'feishu' });
+  } catch (err) {
+    if (err instanceof NeedAuthorizationError) return jsonError('User authorization expired.');
+    throw err;
+  }
+}
+
+export function registerGetUserTool(registry: ToolRegistry): void {
+  registry.register({
+    name: 'feishu_get_user',
+    description: 'Get Feishu user information. Returns current user if user_id not provided.\n\nRequires OAuth authorization.',
+    inputSchema: getUserSchema,
+    handler: async (args, context) => {
+      const p = args as z.infer<ReturnType<typeof z.object<typeof getUserSchema>>>;
+      const { larkClient } = context;
+
+      const tokenResult = await getAccessToken(context);
+      if (typeof tokenResult === 'object' && 'content' in tokenResult) return tokenResult;
+      const accessToken = tokenResult;
+
+      const Lark = await import('@larksuiteoapi/node-sdk');
+      const opts = Lark.withUserAccessToken(accessToken);
+
+      // If no user_id provided, get current user info
+      if (!p.user_id) {
+        log.info('get_user: fetching current user info');
+
+        try {
+          const res = await larkClient!.sdk.authen.userInfo.get({}, opts);
+
+          // Check for API error
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          if ((res as any).code !== undefined && (res as any).code !== 0) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const e = res as any;
+            if (e.code === 41050) {
+              return jsonError('Permission denied. User visibility scope limits access to this user.');
+            }
+            return jsonError(`API Error: code=${e.code}, msg=${e.msg}`);
+          }
+
+          log.info('get_user: current user fetched successfully');
+          return json({ user: res.data });
+        } catch (invokeErr) {
+          // Handle 41050 error
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          if (invokeErr && typeof invokeErr === 'object' && (invokeErr as any).response?.data?.code === 41050) {
+            return jsonError('Permission denied. User visibility scope limits access to this user.');
+          }
+          throw invokeErr;
+        }
+      }
+
+      // Get specific user info
+      log.info(`get_user: fetching user ${p.user_id}`);
+
+      const userIdType = p.user_id_type || 'open_id';
+
+      try {
+        const res = await larkClient!.sdk.contact.v3.user.get(
+          {
+            path: { user_id: p.user_id },
+            params: { user_id_type: userIdType as 'open_id' | 'union_id' | 'user_id' },
+          },
+          opts
+        );
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if ((res as any).code !== undefined && (res as any).code !== 0) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const e = res as any;
+          if (e.code === 41050) {
+            return jsonError('Permission denied. User visibility scope limits access to this user.');
+          }
+          return jsonError(`API Error: code=${e.code}, msg=${e.msg}`);
+        }
+
+        log.info(`get_user: user ${p.user_id} fetched successfully`);
+        return json({ user: res.data?.user });
+      } catch (invokeErr) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (invokeErr && typeof invokeErr === 'object' && (invokeErr as any).response?.data?.code === 41050) {
+          return jsonError('Permission denied. User visibility scope limits access to this user.');
+        }
+        throw invokeErr;
+      }
+    },
+  });
+
+  log.debug('feishu_get_user tool registered');
+}

package/src/tools/common/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Common Tools Index
+ *
+ * User-related tools for Feishu/Lark.
+ */
+
+import type { ToolRegistry } from '../index.js';
+import { registerGetUserTool } from './get-user.js';
+import { registerSearchUserTool } from './search-user.js';
+import { logger } from '../../utils/logger.js';
+
+const log = logger('tools:common');
+
+export function registerCommonTools(registry: ToolRegistry): void {
+  registerGetUserTool(registry);
+  registerSearchUserTool(registry);
+
+  log.info('Common tools registered', {
+    tools: ['feishu_get_user', 'feishu_search_user'].join(', '),
+  });
+}

package/src/tools/common/search-user.ts

@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * feishu_search_user tool - Search for users.
+ */
+
+import { z } from 'zod';
+import type { ToolRegistry } from '../index.js';
+import { LarkClient } from '../../core/lark-client.js';
+import { getValidAccessToken, NeedAuthorizationError } from '../../core/uat-client.js';
+import { json, jsonError, type ToolResult } from '../im/helpers.js';
+import { logger } from '../../utils/logger.js';
+
+const log = logger('tools:common:search-user');
+
+// Schemas
+const searchUserSchema = {
+  query: z.string().describe('Search query (matches user name, phone, email)'),
+  page_size: z.number().min(1).max(200).optional().describe('Page size (default 20)'),
+  page_token: z.string().optional().describe('Pagination token'),
+};
+
+async function getAccessToken(context: { larkClient: LarkClient | null; config: import('../../core/types.js').FeishuConfig }): Promise<string | ToolResult> {
+  const { larkClient, config } = context;
+  if (!larkClient) return jsonError('LarkClient not initialized.');
+  const { appId, appSecret, brand } = config;
+  if (!appId || !appSecret) return jsonError('Missing FEISHU_APP_ID or FEISHU_APP_SECRET.');
+
+  const { listStoredTokens } = await import('../../core/token-store.js');
+  const tokens = await listStoredTokens(appId);
+  if (tokens.length === 0) return jsonError('No user authorization found.');
+  const userOpenId = tokens[0].userOpenId;
+
+  try {
+    return await getValidAccessToken({ userOpenId, appId, appSecret, domain: brand ?? 'feishu' });
+  } catch (err) {
+    if (err instanceof NeedAuthorizationError) return jsonError('User authorization expired.');
+    throw err;
+  }
+}
+
+export function registerSearchUserTool(registry: ToolRegistry): void {
+  registry.register({
+    name: 'feishu_search_user',
+    description: 'Search for Feishu users by name, phone, or email.\n\nRequires OAuth authorization.',
+    inputSchema: searchUserSchema,
+    handler: async (args, context) => {
+      const p = args as z.infer<ReturnType<typeof z.object<typeof searchUserSchema>>>;
+      const { larkClient } = context;
+
+      const tokenResult = await getAccessToken(context);
+      if (typeof tokenResult === 'object' && 'content' in tokenResult) return tokenResult;
+      const accessToken = tokenResult;
+
+      log.info(`search_user: query="${p.query}", page_size=${p.page_size ?? 20}`);
+
+      const Lark = await import('@larksuiteoapi/node-sdk');
+      const opts = Lark.withUserAccessToken(accessToken);
+
+      // Build query parameters
+      const queryParams: Record<string, string> = {
+        query: p.query,
+        page_size: String(p.page_size ?? 20),
+      };
+      if (p.page_token) queryParams.page_token = p.page_token;
+
+      // Use direct request since SDK search API may not be fully typed
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const res = await (larkClient!.sdk as any).request({
+        method: 'GET',
+        url: '/open-apis/search/v1/user',
+        params: queryParams,
+        headers: { Authorization: `Bearer ${accessToken}` },
+      }, opts);
+
+      // Check for API error
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if ((res as any).code !== undefined && (res as any).code !== 0) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return jsonError(`API Error: code=${(res as any).code}, msg=${(res as any).msg}`);
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const data = res.data as any;
+      const users = data?.users ?? [];
+
+      log.info(`search_user: found ${users.length} users`);
+
+      return json({
+        users,
+        has_more: data?.has_more ?? false,
+        page_token: data?.page_token,
+      });
+    },
+  });
+
+  log.debug('feishu_search_user tool registered');
+}

package/src/tools/doc/create.ts

@@ -0,0 +1,184 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * feishu_create_doc tool - Create a new docx document from Markdown.
+ *
+ * Creates a new Feishu document from Markdown content.
+ * Supports async task status checking via task_id.
+ *
+ * Adapted from openclaw-lark for MCP Server architecture.
+ */
+
+import { z } from 'zod';
+import type { ToolRegistry } from '../index.js';
+import { LarkClient } from '../../core/lark-client.js';
+import { getValidAccessToken, NeedAuthorizationError } from '../../core/uat-client.js';
+import { callMcpTool, json, jsonError, processMcpResult, type ToolResult } from './shared.js';
+import { logger } from '../../utils/logger.js';
+
+const log = logger('tools:doc:create');
+
+// ---------------------------------------------------------------------------
+// Input schema
+// ---------------------------------------------------------------------------
+
+const createDocSchema = {
+  markdown: z.string().optional().describe('Markdown content for the document'),
+  title: z.string().optional().describe('Document title'),
+  folder_token: z.string().optional().describe('Parent folder token (optional)'),
+  wiki_node: z
+    .string()
+    .optional()
+    .describe('Wiki node token or URL (optional, creates document under this node)'),
+  wiki_space: z.string().optional().describe('Wiki space ID (optional, special value: my_library)'),
+  task_id: z
+    .string()
+    .optional()
+    .describe('Async task ID. If provided, queries task status instead of creating a new document'),
+};
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+function validateCreateDocParams(p: Record<string, unknown>): void {
+  // If task_id is provided, we're just querying status
+  if (p.task_id) return;
+
+  // For creating new doc, markdown and title are required
+  if (!p.markdown || !p.title) {
+    throw new Error('create-doc: When not providing task_id, markdown and title are required');
+  }
+
+  // Only one of folder_token, wiki_node, wiki_space can be provided
+  const flags = [p.folder_token, p.wiki_node, p.wiki_space].filter(Boolean);
+  if (flags.length > 1) {
+    throw new Error('create-doc: folder_token / wiki_node / wiki_space are mutually exclusive, provide only one');
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+
+/**
+ * Register the feishu_create_doc tool.
+ */
+export function registerCreateDocTool(registry: ToolRegistry): void {
+  registry.register({
+    name: 'feishu_create_doc',
+    description: [
+      'Create a new Feishu docx document from Markdown content.',
+      '',
+      'Usage:',
+      '- Provide markdown and title to create a new document',
+      '- Provide task_id to check async task status',
+      '- Optionally specify folder_token, wiki_node, or wiki_space for document location',
+      '',
+      'Parameters:',
+      '- markdown: Markdown content for the document (required for new doc)',
+      '- title: Document title (required for new doc)',
+      '- folder_token: Parent folder token (optional)',
+      '- wiki_node: Wiki node token or URL (optional)',
+      '- wiki_space: Wiki space ID (optional)',
+      '- task_id: Async task ID for status check (optional)',
+      '',
+      'Returns:',
+      '- For new doc: { task_id, doc_id } or completed document info',
+      '- For task_id query: { status, result? }',
+      '',
+      'Requires OAuth authorization (use feishu_oauth tool first).',
+    ].join('\n'),
+    inputSchema: createDocSchema,
+    handler: async (args, context) => {
+      return handleCreateDoc(args, context);
+    },
+  });
+
+  log.debug('feishu_create_doc tool registered');
+}
+
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
+
+async function handleCreateDoc(
+  args: unknown,
+  context: { larkClient: LarkClient | null; config: import('../../core/types.js').FeishuConfig }
+): Promise<ToolResult> {
+  const p = args as Record<string, unknown>;
+  const { larkClient, config } = context;
+
+  if (!larkClient) {
+    return jsonError('LarkClient not initialized. Check FEISHU_APP_ID and FEISHU_APP_SECRET.');
+  }
+
+  const { appId, appSecret, brand } = config;
+  if (!appId || !appSecret) {
+    return jsonError('Missing FEISHU_APP_ID or FEISHU_APP_SECRET.');
+  }
+
+  // Validate parameters
+  try {
+    validateCreateDocParams(p);
+  } catch (err) {
+    return jsonError(err instanceof Error ? err.message : String(err));
+  }
+
+  // Get the first stored user token
+  const { listStoredTokens } = await import('../../core/token-store.js');
+  const tokens = await listStoredTokens(appId);
+  if (tokens.length === 0) {
+    return jsonError(
+      'No user authorization found. Please use the feishu_oauth tool with action="authorize" to authorize a user first.'
+    );
+  }
+
+  const userOpenId = tokens[0].userOpenId;
+
+  try {
+    const accessToken = await getValidAccessToken({
+      userOpenId,
+      appId,
+      appSecret,
+      domain: brand ?? 'feishu',
+    });
+
+    log.info('Creating document', {
+      title: p.title,
+      has_markdown: !!p.markdown,
+      folder_token: p.folder_token,
+      wiki_node: p.wiki_node,
+      task_id: p.task_id,
+    });
+
+    // Build MCP tool arguments
+    const mcpArgs: Record<string, unknown> = {};
+    if (p.markdown) mcpArgs.markdown = p.markdown;
+    if (p.title) mcpArgs.title = p.title;
+    if (p.folder_token) mcpArgs.folder_token = p.folder_token;
+    if (p.wiki_node) mcpArgs.wiki_node = p.wiki_node;
+    if (p.wiki_space) mcpArgs.wiki_space = p.wiki_space;
+    if (p.task_id) mcpArgs.task_id = p.task_id;
+
+    // Generate a unique tool call ID
+    const toolCallId = `create-doc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+    // Call the MCP endpoint
+    const result = await callMcpTool('create-doc', mcpArgs, toolCallId, accessToken);
+
+    log.info('Document created/task queried', { result });
+
+    return processMcpResult(result);
+  } catch (err) {
+    if (err instanceof NeedAuthorizationError) {
+      return jsonError(
+        `User authorization required or expired. Please use feishu_oauth tool with action="authorize" to re-authorize.`,
+        { userOpenId }
+      );
+    }
+    log.error('Create document failed', { error: err instanceof Error ? err.message : String(err) });
+    return jsonError(err instanceof Error ? err.message : String(err));
+  }
+}