@m1heng-clawd/feishu 0.1.10 → 0.1.12

package/skills/feishu-task/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: feishu-task
+description: |
+  Feishu Task, tasklist, subtask, comment, and attachment management. Activate when user mentions tasks, tasklists, subtasks, task comments, task attachments, or task links.
+---
+
+# Feishu Task Tools
+
+Tools:
+- `feishu_task_create`
+- `feishu_task_subtask_create`
+- `feishu_task_get`
+- `feishu_task_update`
+- `feishu_task_delete`
+- `feishu_task_comment_create`
+- `feishu_task_comment_list`
+- `feishu_task_comment_get`
+- `feishu_task_comment_update`
+- `feishu_task_comment_delete`
+- `feishu_task_attachment_upload`
+- `feishu_task_attachment_list`
+- `feishu_task_attachment_get`
+- `feishu_task_attachment_delete`
+- `feishu_task_add_tasklist`
+- `feishu_task_remove_tasklist`
+- `feishu_tasklist_create`
+- `feishu_tasklist_get`
+- `feishu_tasklist_list`
+- `feishu_tasklist_update`
+- `feishu_tasklist_delete`
+- `feishu_tasklist_add_members`
+- `feishu_tasklist_remove_members`
+
+## Notes
+
+- `task_guid` can be taken from a task URL (guid query param) or from `feishu_task_get` output.
+- `comment_id` can be obtained from `feishu_task_comment_list` output.
+- `attachment_guid` can be obtained from `feishu_task_attachment_list` output.
+- `user_id_type` controls returned/accepted user identity type (`open_id`, `user_id`, `union_id`).
+- If no assignee is specified, set the assignee to the requesting user. Avoid creating unassigned tasks because the user may not be able to view them.
+- Task visibility: users can only view tasks when they are included as assignee.
+- Current limitation: the bot can only create subtasks for tasks created by itself.
+- Attachment upload supports local `file_path` and remote `file_url`. Remote URLs are fetched with runtime media safety checks and size limit (`mediaMaxMb`).
+- Keep tasklist owner as the bot. Add users as members to avoid losing bot access.
+- Use tasklist tools for tasklist membership changes; do not use `feishu_task_update` to move tasks between tasklists.
+
+## Create Task
+
+```json
+{
+  "summary": "Quarterly review",
+  "description": "Prepare review notes",
+  "due": { "timestamp": "1735689600000", "is_all_day": true },
+  "members": [
+    { "id": "ou_xxx", "role": "assignee", "type": "user" }
+  ],
+  "user_id_type": "open_id"
+}
+```
+
+## Create Subtask
+
+```json
+{
+  "task_guid": "e297ddff-06ca-4166-b917-4ce57cd3a7a0",
+  "summary": "Draft report outline",
+  "description": "Collect key metrics",
+  "due": { "timestamp": "1735689600000", "is_all_day": true },
+  "members": [
+    { "id": "ou_xxx", "role": "assignee", "type": "user" }
+  ],
+  "user_id_type": "open_id"
+}
+```
+
+## Create Comment
+
+```json
+{
+  "task_guid": "e297ddff-06ca-4166-b917-4ce57cd3a7a0",
+  "content": "Looks good to me",
+  "user_id_type": "open_id"
+}
+```
+
+## Upload Attachment (file_path)
+
+```json
+{
+  "task_guid": "e297ddff-06ca-4166-b917-4ce57cd3a7a0",
+  "file_path": "/path/to/report.pdf",
+  "user_id_type": "open_id"
+}
+```
+
+## Upload Attachment (file_url)
+
+```json
+{
+  "task_guid": "e297ddff-06ca-4166-b917-4ce57cd3a7a0",
+  "file_url": "https://oss-example.com/bucket/report.pdf",
+  "filename": "report.pdf",
+  "user_id_type": "open_id"
+}
+```
+
+## Tasklist Membership For Tasks
+
+### Add Task to Tasklist
+
+```json
+{
+  "task_guid": "e297ddff-06ca-4166-b917-4ce57cd3a7a0",
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004",
+  "section_guid": "6d0f9f48-2e06-4e3d-8a0f-acde196e8c61",
+  "user_id_type": "open_id"
+}
+```
+
+### Remove Task from Tasklist
+
+```json
+{
+  "task_guid": "e297ddff-06ca-4166-b917-4ce57cd3a7a0",
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004",
+  "user_id_type": "open_id"
+}
+```
+
+## Tasklists
+
+Tasklists support three roles: owner (read/edit/manage), editor (read/edit), viewer (read).
+
+### Create Tasklist
+
+```json
+{
+  "name": "Project Alpha Tasklist",
+  "members": [
+    { "id": "ou_xxx", "type": "user", "role": "editor" }
+  ],
+  "user_id_type": "open_id"
+}
+```
+
+### Get Tasklist
+
+```json
+{
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004",
+  "user_id_type": "open_id"
+}
+```
+
+### List Tasklists
+
+```json
+{
+  "page_size": 50,
+  "page_token": "aWQ9NzEwMjMzMjMxMDE=",
+  "user_id_type": "open_id"
+}
+```
+
+### Update Tasklist
+
+```json
+{
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004",
+  "tasklist": {
+    "name": "Renamed Tasklist",
+    "owner": { "id": "ou_xxx", "type": "user", "role": "owner" }
+  },
+  "update_fields": ["name", "owner"],
+  "origin_owner_to_role": "editor",
+  "user_id_type": "open_id"
+}
+```
+
+### Delete Tasklist
+
+```json
+{
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004"
+}
+```
+
+### Add Tasklist Members
+
+```json
+{
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004",
+  "members": [
+    { "id": "ou_xxx", "type": "user", "role": "editor" }
+  ],
+  "user_id_type": "open_id"
+}
+```
+
+### Remove Tasklist Members
+
+```json
+{
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004",
+  "members": [
+    { "id": "ou_xxx", "type": "user", "role": "viewer" }
+  ],
+  "user_id_type": "open_id"
+}
+```

package/src/bitable-tools/index.ts

@@ -0,0 +1 @@
+export { registerFeishuBitableTools } from "./register.js";

package/src/bot.ts

@@ -4,6 +4,7 @@ import {
   recordPendingHistoryEntryIfEnabled,
   clearHistoryEntriesIfEnabled,
   DEFAULT_GROUP_HISTORY_LIMIT,
+  resolveMentionGatingWithBypass,
   type HistoryEntry,
 } from "openclaw/plugin-sdk";
 import type { FeishuConfig, FeishuMessageContext, FeishuMediaInfo, ResolvedFeishuAccount } from "./types.js";
@@ -14,6 +15,7 @@ import { tryRecordMessage } from "./dedup.js";
 import {
   resolveFeishuGroupConfig,
   resolveFeishuReplyPolicy,
+  resolveFeishuGroupCommandMentionBypass,
   resolveFeishuAllowlistMatch,
   isFeishuGroupAllowed,
 } from "./policy.js";
@@ -145,6 +147,40 @@ async function resolveFeishuSenderName(params: {
   }
 }
 
+// Cache group bot counts for command mention bypass policy checks.
+const GROUP_BOT_COUNT_TTL_MS = 10 * 60 * 1000;
+const groupBotCountCache = new Map<string, { count: number; expireAt: number }>();
+
+async function resolveFeishuGroupBotCount(params: {
+  account: ResolvedFeishuAccount;
+  chatId: string;
+  log: (...args: any[]) => void;
+}): Promise<number | undefined> {
+  const { account, chatId, log } = params;
+  if (!account.configured || !chatId) return undefined;
+
+  const cacheKey = `${account.accountId}:${chatId}`;
+  const now = Date.now();
+  const cached = groupBotCountCache.get(cacheKey);
+  if (cached && cached.expireAt > now) return cached.count;
+
+  try {
+    const client = createFeishuClient(account);
+    const res: any = await client.im.chat.get({
+      path: { chat_id: chatId },
+    });
+    const parsed = Number.parseInt(String(res?.data?.bot_count ?? ""), 10);
+    if (Number.isFinite(parsed) && parsed >= 0) {
+      groupBotCountCache.set(cacheKey, { count: parsed, expireAt: now + GROUP_BOT_COUNT_TTL_MS });
+      return parsed;
+    }
+    return undefined;
+  } catch (err) {
+    log(`feishu[${account.accountId}]: failed to resolve bot_count for ${chatId}: ${String(err)}`);
+    return undefined;
+  }
+}
+
 export type FeishuMessageEvent = {
   sender: {
     sender_id: {
@@ -204,13 +240,21 @@ function parseMessageContent(content: string, messageType: string): string {
   }
 }
 
-function checkBotMentioned(event: FeishuMessageEvent, botOpenId?: string): boolean {
+function checkBotMentioned(
+  event: FeishuMessageEvent,
+  botOpenId?: string,
+  postMentionIds: string[] = [],
+): boolean {
+  const normalizedBotOpenId = botOpenId?.trim();
+  // Keep explicit bot mention semantics: without a resolved botOpenId, do not trigger.
+  if (!normalizedBotOpenId) return false;
+
   const mentions = event.message.mentions ?? [];
-  if (mentions.length === 0) return false;
-  // Fallback for degraded startup/probe scenarios: if botOpenId is unavailable,
-  // keep historical behavior and treat any mention as a mention trigger.
-  if (!botOpenId) return mentions.length > 0;
-  return mentions.some((m) => m.id.open_id === botOpenId);
+  return (
+    mentions.some(
+      (m) => m.id.open_id === normalizedBotOpenId || m.id.user_id === normalizedBotOpenId,
+    ) || postMentionIds.some((id) => id === normalizedBotOpenId)
+  );
 }
 
 function stripBotMention(text: string, mentions?: FeishuMessageEvent["message"]["mentions"]): string {
@@ -263,6 +307,7 @@ function parseMediaKeys(
 function parsePostContent(content: string): {
   textContent: string;
   imageKeys: string[];
+  mentionIds: string[];
 } {
   try {
     const parsed = JSON.parse(content);
@@ -270,6 +315,7 @@ function parsePostContent(content: string): {
     const contentBlocks = parsed.content || [];
     let textContent = title ? `${title}\n\n` : "";
     const imageKeys: string[] = [];
+    const mentionIds: string[] = [];
 
     for (const paragraph of contentBlocks) {
       if (Array.isArray(paragraph)) {
@@ -281,7 +327,11 @@ function parsePostContent(content: string): {
             textContent += element.text || element.href || "";
           } else if (element.tag === "at") {
             // Mention: @username
-            textContent += `@${element.user_name || element.user_id || ""}`;
+            const mentionId =
+              String(element.open_id ?? element.user_id ?? element.union_id ?? "").trim() ||
+              undefined;
+            if (mentionId) mentionIds.push(mentionId);
+            textContent += `@${element.user_name || mentionId || ""}`;
           } else if (element.tag === "img" && element.image_key) {
             // Embedded image
             imageKeys.push(element.image_key);
@@ -294,9 +344,10 @@ function parsePostContent(content: string): {
     return {
       textContent: textContent.trim() || "[富文本消息]",
       imageKeys,
+      mentionIds,
     };
   } catch {
-    return { textContent: "[富文本消息]", imageKeys: [] };
+    return { textContent: "[富文本消息]", imageKeys: [], mentionIds: [] };
   }
 }
 
@@ -480,8 +531,12 @@ export function parseFeishuMessageEvent(
   event: FeishuMessageEvent,
   botOpenId?: string,
 ): FeishuMessageContext {
+  const parsedPost =
+    event.message.message_type === "post" ? parsePostContent(event.message.content) : undefined;
   const rawContent = parseMessageContent(event.message.content, event.message.message_type);
-  const mentionedBot = checkBotMentioned(event, botOpenId);
+  const mentionedBot = checkBotMentioned(event, botOpenId, parsedPost?.mentionIds ?? []);
+  const hasAnyMention =
+    (event.message.mentions?.length ?? 0) > 0 || (parsedPost?.mentionIds.length ?? 0) > 0;
   const content = stripBotMention(rawContent, event.message.mentions);
 
   const ctx: FeishuMessageContext = {
@@ -495,6 +550,7 @@ export function parseFeishuMessageEvent(
     parentId: event.message.parent_id || undefined,
     content,
     contentType: event.message.message_type,
+    hasAnyMention,
   };
 
   // Detect mention forward request: message mentions bot + at least one other user
@@ -520,11 +576,11 @@ export async function handleFeishuMessage(params: {
   accountId?: string;
 }): Promise<void> {
   const { cfg, event, botOpenId, runtime, chatHistories, accountId } = params;
-  
+
   // Resolve account with merged config
   const account = resolveFeishuAccount({ cfg, accountId });
   const feishuCfg = account.config;
-  
+
   const log = runtime?.log ?? console.log;
   const error = runtime?.error ?? console.error;
 
@@ -579,69 +635,17 @@ export async function handleFeishuMessage(params: {
   const configAllowFrom = feishuCfg?.allowFrom ?? [];
   const useAccessGroups = cfg.commands?.useAccessGroups !== false;
 
-  if (isGroup) {
-    const groupPolicy = feishuCfg?.groupPolicy ?? "open";
-    const groupAllowFrom = feishuCfg?.groupAllowFrom ?? [];
-
-    // Check if this GROUP is allowed (groupAllowFrom contains group IDs like oc_xxx, not user IDs)
-    const groupAllowed = isFeishuGroupAllowed({
-      groupPolicy,
-      allowFrom: groupAllowFrom,
-      senderId: ctx.chatId, // Check group ID, not sender ID
-      senderName: undefined,
-    });
-
-    if (!groupAllowed) {
-      log(`feishu[${account.accountId}]: sender ${ctx.senderOpenId} not in group allowlist`);
-      return;
-    }
-
-    // Additional sender-level allowlist check if group has specific allowFrom config
-    const senderAllowFrom = groupConfig?.allowFrom ?? [];
-    if (senderAllowFrom.length > 0) {
-      const senderAllowed = isFeishuGroupAllowed({
-        groupPolicy: "allowlist",
-        allowFrom: senderAllowFrom,
-        senderId: ctx.senderOpenId,
-        senderName: ctx.senderName,
-      });
-      if (!senderAllowed) {
-        log(`feishu: sender ${ctx.senderOpenId} not in group ${ctx.chatId} sender allowlist`);
-        return;
-      }
-    }
-
-    const { requireMention } = resolveFeishuReplyPolicy({
-      isDirectMessage: false,
-      globalConfig: feishuCfg,
-      groupConfig,
-    });
-
-    if (requireMention && !ctx.mentionedBot) {
-      log(`feishu[${account.accountId}]: message in group ${ctx.chatId} did not mention bot, recording to history`);
-      if (chatHistories) {
-        recordPendingHistoryEntryIfEnabled({
-          historyMap: chatHistories,
-          historyKey: ctx.chatId,
-          limit: historyLimit,
-          entry: {
-            sender: ctx.senderOpenId,
-            body: `${ctx.senderName ?? ctx.senderOpenId}: ${ctx.content}`,
-            timestamp: Date.now(),
-            messageId: ctx.messageId,
-          },
-        });
-      }
-      return;
-    }
-  }
-
   try {
     const core = getFeishuRuntime();
     const shouldComputeCommandAuthorized = core.channel.commands.shouldComputeCommandAuthorized(
       ctx.content,
       cfg,
     );
+    const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
+      cfg,
+      surface: "feishu",
+    });
+    const hasControlCommand = core.channel.text.hasControlCommand(ctx.content, cfg);
     const storeAllowFrom =
       !isGroup && (dmPolicy !== "open" || shouldComputeCommandAuthorized)
         ? await core.channel.pairing.readAllowFromStore("feishu").catch(() => [])
@@ -687,7 +691,11 @@ export async function handleFeishuMessage(params: {
       return;
     }
 
-    const commandAllowFrom = isGroup ? (groupConfig?.allowFrom ?? []) : effectiveDmAllowFrom;
+    const commandAllowFrom = isGroup
+      ? groupConfig?.allowFrom && groupConfig.allowFrom.length > 0
+        ? groupConfig.allowFrom
+        : configAllowFrom
+      : effectiveDmAllowFrom;
     const senderAllowedForCommands = resolveFeishuAllowlistMatch({
       allowFrom: commandAllowFrom,
       senderId: ctx.senderOpenId,
@@ -701,6 +709,105 @@ export async function handleFeishuMessage(params: {
           ],
         })
       : undefined;
+    let effectiveWasMentioned = ctx.mentionedBot;
+
+    if (isGroup) {
+      if (groupConfig?.enabled === false) {
+        log(`feishu[${account.accountId}]: group ${ctx.chatId} is disabled`);
+        return;
+      }
+
+      const groupPolicy = feishuCfg?.groupPolicy ?? "open";
+      const groupAllowFrom = feishuCfg?.groupAllowFrom ?? [];
+
+      // Check if this GROUP is allowed (groupAllowFrom contains group IDs like oc_xxx, not user IDs)
+      const groupAllowed = isFeishuGroupAllowed({
+        groupPolicy,
+        allowFrom: groupAllowFrom,
+        senderId: ctx.chatId, // Check group ID, not sender ID
+        senderName: undefined,
+      });
+
+      if (!groupAllowed) {
+        log(`feishu[${account.accountId}]: group ${ctx.chatId} not in groupAllowFrom (groupPolicy=${groupPolicy})`);
+        return;
+      }
+
+      // Additional sender-level allowlist check if group has specific allowFrom config
+      const senderAllowFrom = groupConfig?.allowFrom ?? [];
+      if (senderAllowFrom.length > 0) {
+        const senderAllowed = isFeishuGroupAllowed({
+          groupPolicy: "allowlist",
+          allowFrom: senderAllowFrom,
+          senderId: ctx.senderOpenId,
+          senderName: ctx.senderName,
+        });
+        if (!senderAllowed) {
+          log(`feishu: sender ${ctx.senderOpenId} not in group ${ctx.chatId} sender allowlist`);
+          return;
+        }
+      }
+
+      const { requireMention } = resolveFeishuReplyPolicy({
+        isDirectMessage: false,
+        globalConfig: feishuCfg,
+        groupConfig,
+      });
+
+      if (requireMention) {
+        const bypassPolicy = resolveFeishuGroupCommandMentionBypass({
+          globalConfig: feishuCfg,
+          groupConfig,
+        });
+        let bypassAllowedByPolicy = bypassPolicy === "always";
+
+        if (!bypassAllowedByPolicy && bypassPolicy === "single_bot" && hasControlCommand) {
+          const botCount = await resolveFeishuGroupBotCount({
+            account,
+            chatId: ctx.chatId,
+            log,
+          });
+          bypassAllowedByPolicy = botCount !== undefined && botCount <= 1;
+          if (botCount === undefined) {
+            log(
+              `feishu[${account.accountId}]: unable to resolve bot count for ${ctx.chatId}, command mention bypass disabled`,
+            );
+          }
+        }
+
+        const mentionGate = resolveMentionGatingWithBypass({
+          isGroup: true,
+          requireMention,
+          canDetectMention: true,
+          wasMentioned: ctx.mentionedBot,
+          hasAnyMention: ctx.hasAnyMention,
+          allowTextCommands: allowTextCommands && bypassAllowedByPolicy,
+          hasControlCommand,
+          commandAuthorized: commandAuthorized === true,
+        });
+        effectiveWasMentioned = mentionGate.effectiveWasMentioned;
+
+        if (mentionGate.shouldSkip) {
+          log(
+            `feishu[${account.accountId}]: message in group ${ctx.chatId} skipped (mention required)`,
+          );
+          if (chatHistories) {
+            recordPendingHistoryEntryIfEnabled({
+              historyMap: chatHistories,
+              historyKey: ctx.chatId,
+              limit: historyLimit,
+              entry: {
+                sender: ctx.senderOpenId,
+                body: `${ctx.senderName ?? ctx.senderOpenId}: ${ctx.content}`,
+                timestamp: Date.now(),
+                messageId: ctx.messageId,
+              },
+            });
+          }
+          return;
+        }
+      }
+    }
 
     // In group chats, the session is scoped to the group, but the *speaker* is the sender.
     // Using a group-scoped From causes the agent to treat different users as the same person.
@@ -764,8 +871,11 @@ export async function handleFeishuMessage(params: {
     const inboundLabel = isGroup
       ? `Feishu[${account.accountId}] message in group ${ctx.chatId}`
       : `Feishu[${account.accountId}] DM from ${ctx.senderOpenId}`;
+    const systemEventText = permissionErrorForAgent
+      ? inboundLabel
+      : `${inboundLabel}: ${preview}`;
 
-    core.system.enqueueSystemEvent(`${inboundLabel}: ${preview}`, {
+    core.system.enqueueSystemEvent(systemEventText, {
       sessionKey: route.sessionKey,
       contextKey: `feishu:message:${ctx.chatId}:${ctx.messageId}`,
     });
@@ -929,10 +1039,11 @@ export async function handleFeishuMessage(params: {
       Surface: "feishu" as const,
       MessageSid: ctx.messageId,
       Timestamp: Date.now(),
-      WasMentioned: ctx.mentionedBot,
+      WasMentioned: effectiveWasMentioned,
       CommandAuthorized: commandAuthorized,
       OriginatingChannel: "feishu" as const,
       OriginatingTo: feishuTo,
+      ReplyToBody: quotedContent,
       ...mediaPayload,
     });
 

package/src/channel.ts

@@ -90,6 +90,7 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
         groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
         groupAllowFrom: { type: "array", items: { oneOf: [{ type: "string" }, { type: "number" }] } },
         requireMention: { type: "boolean" },
+        groupCommandMentionBypass: { type: "string", enum: ["never", "single_bot", "always"] },
         topicSessionMode: { type: "string", enum: ["disabled", "enabled"] },
         historyLimit: { type: "integer", minimum: 0 },
         dmHistoryLimit: { type: "integer", minimum: 0 },
@@ -110,6 +111,7 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
               verificationToken: { type: "string" },
               domain: { type: "string", enum: ["feishu", "lark"] },
               connectionMode: { type: "string", enum: ["websocket", "webhook"] },
+              groupCommandMentionBypass: { type: "string", enum: ["never", "single_bot", "always"] },
             },
           },
         },

package/src/config-schema.ts

@@ -3,6 +3,7 @@ export { z };
 
 const DmPolicySchema = z.enum(["open", "pairing", "allowlist"]);
 const GroupPolicySchema = z.enum(["open", "allowlist", "disabled"]);
+const GroupCommandMentionBypassSchema = z.enum(["never", "single_bot", "always"]).optional();
 const FeishuDomainSchema = z.union([
   z.enum(["feishu", "lark"]),
   z.string().url().startsWith("https://"),
@@ -104,6 +105,7 @@ const TopicSessionModeSchema = z.enum(["disabled", "enabled"]).optional();
 export const FeishuGroupSchema = z
   .object({
     requireMention: z.boolean().optional(),
+    groupCommandMentionBypass: GroupCommandMentionBypassSchema,
     tools: ToolPolicySchema,
     skills: z.array(z.string()).optional(),
     enabled: z.boolean().optional(),
@@ -137,6 +139,7 @@ export const FeishuAccountConfigSchema = z
     groupPolicy: GroupPolicySchema.optional(),
     groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
     requireMention: z.boolean().optional(),
+    groupCommandMentionBypass: GroupCommandMentionBypassSchema,
     groups: z.record(z.string(), FeishuGroupSchema.optional()).optional(),
     historyLimit: z.number().int().min(0).optional(),
     dmHistoryLimit: z.number().int().min(0).optional(),
@@ -172,6 +175,7 @@ export const FeishuConfigSchema = z
     groupPolicy: GroupPolicySchema.optional().default("allowlist"),
     groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
     requireMention: z.boolean().optional().default(true),
+    groupCommandMentionBypass: GroupCommandMentionBypassSchema.default("single_bot"),
     groups: z.record(z.string(), FeishuGroupSchema.optional()).optional(),
     topicSessionMode: TopicSessionModeSchema,
     historyLimit: z.number().int().min(0).optional(),