@bobotu/feishu-fork 0.1.0

package/src/task-tools/schemas.ts

@@ -0,0 +1,567 @@
+import { Type } from "@sinclair/typebox";
+import type { TaskClient } from "./common.js";
+
+type TaskCreatePayload = NonNullable<Parameters<TaskClient["task"]["v2"]["task"]["create"]>[0]>;
+type TaskUpdatePayload = NonNullable<Parameters<TaskClient["task"]["v2"]["task"]["patch"]>[0]>;
+type TaskDeletePayload = NonNullable<Parameters<TaskClient["task"]["v2"]["task"]["delete"]>[0]>;
+type TaskGetPayload = NonNullable<Parameters<TaskClient["task"]["v2"]["task"]["get"]>[0]>;
+type TaskAddTasklistPayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["task"]["addTasklist"]>[0]
+>;
+type TaskRemoveTasklistPayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["task"]["removeTasklist"]>[0]
+>;
+type TaskCommentCreatePayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["comment"]["create"]>[0]
+>;
+type TaskCommentGetPayload = NonNullable<Parameters<TaskClient["task"]["v2"]["comment"]["get"]>[0]>;
+type TaskCommentListPayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["comment"]["list"]>[0]
+>;
+type TaskCommentPatchPayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["comment"]["patch"]>[0]
+>;
+type TaskCommentDeletePayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["comment"]["delete"]>[0]
+>;
+type TaskAttachmentUploadPayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["attachment"]["upload"]>[0]
+>;
+type TaskAttachmentGetPayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["attachment"]["get"]>[0]
+>;
+type TaskAttachmentListPayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["attachment"]["list"]>[0]
+>;
+type TaskAttachmentDeletePayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["attachment"]["delete"]>[0]
+>;
+type TasklistCreatePayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["tasklist"]["create"]>[0]
+>;
+type TasklistGetPayload = NonNullable<Parameters<TaskClient["task"]["v2"]["tasklist"]["get"]>[0]>;
+type TasklistListPayload = NonNullable<Parameters<TaskClient["task"]["v2"]["tasklist"]["list"]>[0]>;
+type TasklistPatchPayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["tasklist"]["patch"]>[0]
+>;
+type TasklistDeletePayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["tasklist"]["delete"]>[0]
+>;
+type TasklistAddMembersPayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["tasklist"]["addMembers"]>[0]
+>;
+type TasklistRemoveMembersPayload = NonNullable<
+  Parameters<TaskClient["task"]["v2"]["tasklist"]["removeMembers"]>[0]
+>;
+
+export type TaskCreateData = TaskCreatePayload["data"];
+export type TaskUpdateData = TaskUpdatePayload["data"];
+export type TaskUpdateTask = NonNullable<TaskUpdateData["task"]>;
+export type TaskCommentPatchData = TaskCommentPatchPayload["data"];
+export type TaskCommentPatchComment = TaskCommentPatchData["comment"];
+export type TasklistCreateData = TasklistCreatePayload["data"];
+export type TasklistPatchData = TasklistPatchPayload["data"];
+export type TasklistPatchTasklist = NonNullable<TasklistPatchData["tasklist"]>;
+export type TasklistMember = NonNullable<NonNullable<TasklistCreateData["members"]>[number]>;
+
+export const TASK_UPDATE_FIELD_VALUES = [
+  "summary",
+  "description",
+  "due",
+  "start",
+  "extra",
+  "completed_at",
+  "repeat_rule",
+  "mode",
+  "is_milestone",
+] as const;
+export const TASKLIST_UPDATE_FIELD_VALUES = ["name", "owner", "archive_tasklist"] as const;
+
+export type CreateTaskParams = {
+  summary: TaskCreateData["summary"];
+  description?: TaskCreateData["description"];
+  due?: TaskCreateData["due"];
+  start?: TaskCreateData["start"];
+  extra?: TaskCreateData["extra"];
+  completed_at?: TaskCreateData["completed_at"];
+  members?: TaskCreateData["members"];
+  repeat_rule?: TaskCreateData["repeat_rule"];
+  tasklists?: TaskCreateData["tasklists"];
+  mode?: TaskCreateData["mode"];
+  is_milestone?: TaskCreateData["is_milestone"];
+  user_id_type?: NonNullable<TaskCreatePayload["params"]>["user_id_type"];
+};
+
+export type CreateSubtaskParams = CreateTaskParams & {
+  task_guid: string;
+};
+
+export type DeleteTaskParams = {
+  task_guid: TaskDeletePayload["path"]["task_guid"];
+};
+
+export type GetTaskParams = {
+  task_guid: TaskGetPayload["path"]["task_guid"];
+  user_id_type?: NonNullable<TaskGetPayload["params"]>["user_id_type"];
+};
+
+export type UpdateTaskParams = {
+  task_guid: TaskUpdatePayload["path"]["task_guid"];
+  task: TaskUpdateTask;
+  update_fields?: TaskUpdateData["update_fields"];
+  user_id_type?: NonNullable<TaskUpdatePayload["params"]>["user_id_type"];
+};
+
+export type AddTaskToTasklistParams = {
+  task_guid: TaskAddTasklistPayload["path"]["task_guid"];
+  tasklist_guid: NonNullable<TaskAddTasklistPayload["data"]>["tasklist_guid"];
+  section_guid?: NonNullable<TaskAddTasklistPayload["data"]>["section_guid"];
+  user_id_type?: NonNullable<TaskAddTasklistPayload["params"]>["user_id_type"];
+};
+
+export type RemoveTaskFromTasklistParams = {
+  task_guid: TaskRemoveTasklistPayload["path"]["task_guid"];
+  tasklist_guid: NonNullable<TaskRemoveTasklistPayload["data"]>["tasklist_guid"];
+  user_id_type?: NonNullable<TaskRemoveTasklistPayload["params"]>["user_id_type"];
+};
+
+export type CreateTaskCommentParams = {
+  task_guid: string;
+  content: TaskCommentCreatePayload["data"]["content"];
+  reply_to_comment_id?: TaskCommentCreatePayload["data"]["reply_to_comment_id"];
+  user_id_type?: NonNullable<TaskCommentCreatePayload["params"]>["user_id_type"];
+};
+
+export type ListTaskCommentsParams = {
+  task_guid: string;
+  page_size?: NonNullable<TaskCommentListPayload["params"]>["page_size"];
+  page_token?: NonNullable<TaskCommentListPayload["params"]>["page_token"];
+  direction?: NonNullable<TaskCommentListPayload["params"]>["direction"];
+  user_id_type?: NonNullable<TaskCommentListPayload["params"]>["user_id_type"];
+};
+
+export type GetTaskCommentParams = {
+  comment_id: TaskCommentGetPayload["path"]["comment_id"];
+  user_id_type?: NonNullable<TaskCommentGetPayload["params"]>["user_id_type"];
+};
+
+export type UpdateTaskCommentParams = {
+  comment_id: TaskCommentPatchPayload["path"]["comment_id"];
+  comment: TaskCommentPatchComment;
+  update_fields?: TaskCommentPatchData["update_fields"];
+  user_id_type?: NonNullable<TaskCommentPatchPayload["params"]>["user_id_type"];
+};
+
+export type DeleteTaskCommentParams = {
+  comment_id: TaskCommentDeletePayload["path"]["comment_id"];
+};
+
+export type UploadTaskAttachmentParams =
+  | {
+      task_guid: string;
+      file_path: string;
+      user_id_type?: NonNullable<TaskAttachmentUploadPayload["params"]>["user_id_type"];
+    }
+  | {
+      task_guid: string;
+      file_url: string;
+      filename?: string;
+      user_id_type?: NonNullable<TaskAttachmentUploadPayload["params"]>["user_id_type"];
+    };
+
+export type ListTaskAttachmentsParams = {
+  task_guid: NonNullable<TaskAttachmentListPayload["params"]>["resource_id"];
+  page_size?: NonNullable<TaskAttachmentListPayload["params"]>["page_size"];
+  page_token?: NonNullable<TaskAttachmentListPayload["params"]>["page_token"];
+  updated_mesc?: NonNullable<TaskAttachmentListPayload["params"]>["updated_mesc"];
+  user_id_type?: NonNullable<TaskAttachmentListPayload["params"]>["user_id_type"];
+};
+
+export type GetTaskAttachmentParams = {
+  attachment_guid: TaskAttachmentGetPayload["path"]["attachment_guid"];
+  user_id_type?: NonNullable<TaskAttachmentGetPayload["params"]>["user_id_type"];
+};
+
+export type DeleteTaskAttachmentParams = {
+  attachment_guid: NonNullable<TaskAttachmentDeletePayload["path"]>["attachment_guid"];
+};
+
+export type CreateTasklistParams = {
+  name: TasklistCreateData["name"];
+  members?: TasklistCreateData["members"];
+  archive_tasklist?: TasklistCreateData["archive_tasklist"];
+  user_id_type?: NonNullable<TasklistCreatePayload["params"]>["user_id_type"];
+};
+
+export type GetTasklistParams = {
+  tasklist_guid: NonNullable<TasklistGetPayload["path"]>["tasklist_guid"];
+  user_id_type?: NonNullable<TasklistGetPayload["params"]>["user_id_type"];
+};
+
+export type ListTasklistsParams = {
+  page_size?: NonNullable<TasklistListPayload["params"]>["page_size"];
+  page_token?: NonNullable<TasklistListPayload["params"]>["page_token"];
+  user_id_type?: NonNullable<TasklistListPayload["params"]>["user_id_type"];
+};
+
+export type UpdateTasklistParams = {
+  tasklist_guid: NonNullable<TasklistPatchPayload["path"]>["tasklist_guid"];
+  tasklist: TasklistPatchTasklist;
+  update_fields?: TasklistPatchData["update_fields"];
+  origin_owner_to_role?: TasklistPatchData["origin_owner_to_role"];
+  user_id_type?: NonNullable<TasklistPatchPayload["params"]>["user_id_type"];
+};
+
+export type DeleteTasklistParams = {
+  tasklist_guid: NonNullable<TasklistDeletePayload["path"]>["tasklist_guid"];
+};
+
+export type AddTasklistMembersParams = {
+  tasklist_guid: NonNullable<TasklistAddMembersPayload["path"]>["tasklist_guid"];
+  members: NonNullable<NonNullable<TasklistAddMembersPayload["data"]>["members"]>;
+  user_id_type?: NonNullable<TasklistAddMembersPayload["params"]>["user_id_type"];
+};
+
+export type RemoveTasklistMembersParams = {
+  tasklist_guid: NonNullable<TasklistRemoveMembersPayload["path"]>["tasklist_guid"];
+  members: NonNullable<NonNullable<TasklistRemoveMembersPayload["data"]>["members"]>;
+  user_id_type?: NonNullable<TasklistRemoveMembersPayload["params"]>["user_id_type"];
+};
+
+const TaskDateSchema = Type.Object({
+  timestamp: Type.Optional(
+    Type.String({
+      description:
+        'Unix timestamp in milliseconds (string), e.g. "1735689600000" (13-digit ms)',
+    }),
+  ),
+  is_all_day: Type.Optional(Type.Boolean({ description: "Whether this is an all-day date" })),
+});
+
+const TaskMemberSchema = Type.Object({
+  id: Type.String({ description: "Member ID (with type controlled by user_id_type)" }),
+  type: Type.Optional(Type.String({ description: 'Member type (usually "user")' })),
+  role: Type.String({ description: 'Member role, e.g. "assignee"' }),
+  name: Type.Optional(Type.String({ description: "Optional display name" })),
+});
+
+const TasklistRefSchema = Type.Object({
+  tasklist_guid: Type.Optional(Type.String({ description: "Tasklist GUID" })),
+  section_guid: Type.Optional(Type.String({ description: "Section GUID in tasklist" })),
+});
+
+const TaskUpdateFieldSchema = Type.Union(
+  TASK_UPDATE_FIELD_VALUES.map((field) => Type.Literal(field)),
+);
+
+const TasklistMemberRoleSchema = Type.Union(
+  [Type.Literal("owner"), Type.Literal("editor"), Type.Literal("viewer")],
+  { description: "Member role (owner/editor/viewer)" },
+);
+
+const TasklistUpdateFieldSchema = Type.Union(
+  TASKLIST_UPDATE_FIELD_VALUES.map((field) => Type.Literal(field)),
+);
+
+const TasklistOriginOwnerRoleSchema = Type.Union(
+  [Type.Literal("editor"), Type.Literal("viewer"), Type.Literal("none")],
+  { description: "Role for original owner after owner transfer" },
+);
+
+const TasklistMemberSchema = Type.Object({
+  id: Type.String({ description: "Member ID (with type controlled by user_id_type)" }),
+  type: Type.Optional(Type.String({ description: "Member type (user/chat/app)" })),
+  role: Type.Optional(TasklistMemberRoleSchema),
+  name: Type.Optional(Type.String({ description: "Optional display name" })),
+});
+
+export const CreateTaskSchema = Type.Object({
+  summary: Type.String({ description: "Task title/summary" }),
+  description: Type.Optional(Type.String({ description: "Task description" })),
+  due: Type.Optional(TaskDateSchema),
+  start: Type.Optional(TaskDateSchema),
+  extra: Type.Optional(Type.String({ description: "Custom opaque metadata string" })),
+  completed_at: Type.Optional(
+    Type.String({
+      description: "Completion time as Unix timestamp in milliseconds (string, 13-digit ms)",
+    }),
+  ),
+  members: Type.Optional(Type.Array(TaskMemberSchema, { description: "Initial task members" })),
+  repeat_rule: Type.Optional(Type.String({ description: "Task repeat rule" })),
+  tasklists: Type.Optional(
+    Type.Array(TasklistRefSchema, { description: "Attach the task to tasklists/sections" }),
+  ),
+  mode: Type.Optional(Type.Number({ description: "Task mode value from Feishu Task API" })),
+  is_milestone: Type.Optional(Type.Boolean({ description: "Whether task is a milestone" })),
+  user_id_type: Type.Optional(
+    Type.String({
+      description: "User ID type for member IDs, e.g. open_id/user_id/union_id",
+    }),
+  ),
+});
+
+export const CreateSubtaskSchema = Type.Intersect([
+  Type.Object({
+    task_guid: Type.String({ description: "Parent task GUID" }),
+  }),
+  CreateTaskSchema,
+]);
+
+export const DeleteTaskSchema = Type.Object({
+  task_guid: Type.String({ description: "Task GUID to delete" }),
+});
+
+export const GetTaskSchema = Type.Object({
+  task_guid: Type.String({ description: "Task GUID to retrieve" }),
+  user_id_type: Type.Optional(
+    Type.String({
+      description: "User ID type in returned members, e.g. open_id/user_id/union_id",
+    }),
+  ),
+});
+
+const TaskUpdateContentSchema = Type.Object(
+  {
+    summary: Type.Optional(Type.String({ description: "Updated summary" })),
+    description: Type.Optional(Type.String({ description: "Updated description" })),
+    due: Type.Optional(TaskDateSchema),
+    start: Type.Optional(TaskDateSchema),
+    extra: Type.Optional(Type.String({ description: "Updated extra metadata" })),
+    completed_at: Type.Optional(
+      Type.String({
+        description: "Updated completion time (Unix timestamp in milliseconds, string, 13-digit ms)",
+      }),
+    ),
+    repeat_rule: Type.Optional(Type.String({ description: "Updated repeat rule" })),
+    mode: Type.Optional(Type.Number({ description: "Updated task mode" })),
+    is_milestone: Type.Optional(Type.Boolean({ description: "Updated milestone flag" })),
+  },
+  { minProperties: 1 },
+);
+
+export const UpdateTaskSchema = Type.Object({
+  task_guid: Type.String({ description: "Task GUID to update" }),
+  task: TaskUpdateContentSchema,
+  update_fields: Type.Optional(
+    Type.Array(TaskUpdateFieldSchema, {
+      description:
+        "Fields to update. If omitted, this tool infers from keys in task (e.g. summary, description, due, start)",
+      minItems: 1,
+      uniqueItems: true,
+    }),
+  ),
+  user_id_type: Type.Optional(
+    Type.String({
+      description: "User ID type when task body contains user-related fields",
+    }),
+  ),
+});
+
+export const CreateTaskCommentSchema = Type.Object({
+  task_guid: Type.String({ description: "Task GUID to comment on" }),
+  content: Type.String({ description: "Comment content" }),
+  reply_to_comment_id: Type.Optional(
+    Type.String({ description: "Reply to a specific comment ID" }),
+  ),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type when comment involves user-related fields" }),
+  ),
+});
+
+export const ListTaskCommentsSchema = Type.Object({
+  task_guid: Type.String({ description: "Task GUID to list comments for" }),
+  page_size: Type.Optional(
+    Type.Number({
+      description: "Page size (1-100)",
+      minimum: 1,
+      maximum: 100,
+    }),
+  ),
+  page_token: Type.Optional(Type.String({ description: "Pagination token" })),
+  direction: Type.Optional(
+    Type.Union([Type.Literal("asc"), Type.Literal("desc")], {
+      description: "Sort direction",
+    }),
+  ),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type for returned creators" }),
+  ),
+});
+
+export const GetTaskCommentSchema = Type.Object({
+  comment_id: Type.String({ description: "Comment ID to retrieve" }),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type for returned creators" }),
+  ),
+});
+
+const TaskCommentUpdateContentSchema = Type.Object(
+  {
+    content: Type.Optional(Type.String({ description: "Updated comment content" })),
+  },
+  { minProperties: 1 },
+);
+
+export const UpdateTaskCommentSchema = Type.Object({
+  comment_id: Type.String({ description: "Comment ID to update" }),
+  comment: TaskCommentUpdateContentSchema,
+  update_fields: Type.Optional(
+    Type.Array(Type.String(), {
+      description: "Fields to update. If omitted, this tool infers from keys in comment (content)",
+      minItems: 1,
+    }),
+  ),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type for returned creators" }),
+  ),
+});
+
+export const DeleteTaskCommentSchema = Type.Object({
+  comment_id: Type.String({ description: "Comment ID to delete" }),
+});
+
+const TasklistUpdateContentSchema = Type.Object(
+  {
+    name: Type.Optional(Type.String({ description: "Updated tasklist name" })),
+    owner: Type.Optional(TasklistMemberSchema),
+    archive_tasklist: Type.Optional(Type.Boolean({ description: "Archive/unarchive tasklist" })),
+  },
+  { minProperties: 1 },
+);
+
+export const AddTaskToTasklistSchema = Type.Object({
+  task_guid: Type.String({ description: "Task GUID to move" }),
+  tasklist_guid: Type.String({ description: "Tasklist GUID to add the task into" }),
+  section_guid: Type.Optional(Type.String({ description: "Tasklist section GUID" })),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type when task body contains user-related fields" }),
+  ),
+});
+
+export const RemoveTaskFromTasklistSchema = Type.Object({
+  task_guid: Type.String({ description: "Task GUID to move" }),
+  tasklist_guid: Type.String({ description: "Tasklist GUID to remove the task from" }),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type when task body contains user-related fields" }),
+  ),
+});
+
+export const CreateTasklistSchema = Type.Object({
+  name: Type.String({ description: "Tasklist name" }),
+  members: Type.Optional(Type.Array(TasklistMemberSchema, { description: "Initial members" })),
+  archive_tasklist: Type.Optional(
+    Type.Boolean({ description: "Whether to create as archived tasklist" }),
+  ),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type for member IDs, e.g. open_id/user_id/union_id" }),
+  ),
+});
+
+export const GetTasklistSchema = Type.Object({
+  tasklist_guid: Type.String({ description: "Tasklist GUID to retrieve" }),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type in returned members, e.g. open_id/user_id/union_id" }),
+  ),
+});
+
+export const ListTasklistsSchema = Type.Object({
+  page_size: Type.Optional(
+    Type.Number({
+      description: "Page size (1-100)",
+      minimum: 1,
+      maximum: 100,
+    }),
+  ),
+  page_token: Type.Optional(Type.String({ description: "Pagination token" })),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type in returned members, e.g. open_id/user_id/union_id" }),
+  ),
+});
+
+export const UpdateTasklistSchema = Type.Object({
+  tasklist_guid: Type.String({ description: "Tasklist GUID to update" }),
+  tasklist: TasklistUpdateContentSchema,
+  update_fields: Type.Optional(
+    Type.Array(TasklistUpdateFieldSchema, {
+      description:
+        "Fields to update. If omitted, this tool infers from keys in tasklist (e.g. name, owner, archive_tasklist)",
+      minItems: 1,
+      uniqueItems: true,
+    }),
+  ),
+  origin_owner_to_role: Type.Optional(TasklistOriginOwnerRoleSchema),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type when tasklist body contains user-related fields" }),
+  ),
+});
+
+export const DeleteTasklistSchema = Type.Object({
+  tasklist_guid: Type.String({ description: "Tasklist GUID to delete" }),
+});
+
+export const AddTasklistMembersSchema = Type.Object({
+  tasklist_guid: Type.String({ description: "Tasklist GUID to add members to" }),
+  members: Type.Array(TasklistMemberSchema, {
+    description: "Members to add",
+    minItems: 1,
+  }),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type for member IDs, e.g. open_id/user_id/union_id" }),
+  ),
+});
+
+export const RemoveTasklistMembersSchema = Type.Object({
+  tasklist_guid: Type.String({ description: "Tasklist GUID to remove members from" }),
+  members: Type.Array(TasklistMemberSchema, {
+    description: "Members to remove",
+    minItems: 1,
+  }),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type for member IDs, e.g. open_id/user_id/union_id" }),
+  ),
+});
+
+export const UploadTaskAttachmentSchema = Type.Union([
+  Type.Object({
+    task_guid: Type.String({ description: "Task GUID to upload attachment to" }),
+    file_path: Type.String({ description: "Local file path on the OpenClaw host" }),
+    user_id_type: Type.Optional(
+      Type.String({ description: "User ID type for returned uploader" }),
+    ),
+  }),
+  Type.Object({
+    task_guid: Type.String({ description: "Task GUID to upload attachment to" }),
+    file_url: Type.String({ description: "Remote file URL to download and upload" }),
+    filename: Type.Optional(Type.String({ description: "Override filename for uploaded attachment" })),
+    user_id_type: Type.Optional(
+      Type.String({ description: "User ID type for returned uploader" }),
+    ),
+  }),
+]);
+
+export const ListTaskAttachmentsSchema = Type.Object({
+  task_guid: Type.String({ description: "Task GUID to list attachments for" }),
+  page_size: Type.Optional(
+    Type.Number({
+      description: "Page size (1-100)",
+      minimum: 1,
+      maximum: 100,
+    }),
+  ),
+  page_token: Type.Optional(Type.String({ description: "Pagination token" })),
+  updated_mesc: Type.Optional(Type.String({ description: "Updated timestamp filter" })),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type for returned uploader" }),
+  ),
+});
+
+export const GetTaskAttachmentSchema = Type.Object({
+  attachment_guid: Type.String({ description: "Attachment GUID to retrieve" }),
+  user_id_type: Type.Optional(
+    Type.String({ description: "User ID type for returned uploader" }),
+  ),
+});
+
+export const DeleteTaskAttachmentSchema = Type.Object({
+  attachment_guid: Type.String({ description: "Attachment GUID to delete" }),
+});

package/src/text/markdown-links.ts

@@ -0,0 +1,104 @@
+const FENCED_CODE_BLOCK_RE = /(```[\s\S]*?```)/g;
+const INLINE_CODE_RE = /(`[^`\n]*`)/g;
+const URL_RE = /https?:\/\/[^\s<>"'`]+/g;
+const TRAILING_PUNCT_RE = /[.,;!?\u3002\uff0c\uff1b\uff01\uff1f\u3001]/u;
+const AUTO_LINK_RE = /<\s*(https?:\/\/[^>\s]+)\s*>/g;
+
+// Feishu markdown can mis-handle some URL characters in edge cases.
+// Encode a minimal safe subset while preserving URL semantics.
+function normalizeUrlForFeishu(url: string): string {
+  return url.replace(/_/g, "%5F").replace(/\(/g, "%28").replace(/\)/g, "%29");
+}
+
+// We intentionally convert raw/autolink URLs into explicit markdown links.
+// Why: in Feishu message rendering, plain URLs (including "<...>" autolinks)
+// can be re-tokenized and visually split/truncated on characters like "_"
+// or around long query strings. The explicit "[label](url)" form is more stable
+// in post/card markdown parsing and keeps the link clickable end-to-end.
+function buildMarkdownLink(url: string): string {
+  const label = url.replace(/[\[\]]/g, "\\$&");
+  return `[${label}](${url})`;
+}
+
+// We only need balance info to detect whether a trailing ")" belongs to the URL.
+function countParens(text: string): { open: number; close: number } {
+  let open = 0;
+  let close = 0;
+  for (const c of text) {
+    if (c === "(") {
+      open += 1;
+    } else if (c === ")") {
+      close += 1;
+    }
+  }
+  return { open, close };
+}
+
+function splitTrailingPunctuation(rawUrl: string): { url: string; trailing: string } {
+  let url = rawUrl;
+  let trailing = "";
+  let { open, close } = countParens(rawUrl);
+
+  while (url.length > 0) {
+    const tail = url.slice(-1);
+    // Many links appear as ".../path),". Strip punctuation that is not part of the URL.
+    const closeParenOverflow = tail === ")" && close > open;
+    if (!TRAILING_PUNCT_RE.test(tail) && !closeParenOverflow) {
+      break;
+    }
+    if (tail === ")") {
+      close -= 1;
+    }
+    trailing = tail + trailing;
+    url = url.slice(0, -1);
+  }
+
+  return { url, trailing };
+}
+
+function wrapBareUrls(text: string): string {
+  // Normalize "<https://...>" to explicit markdown links for better Feishu stability.
+  const convertedAutoLinks = text.replace(AUTO_LINK_RE, (_full, rawUrl: string) => {
+    const { url, trailing } = splitTrailingPunctuation(rawUrl);
+    if (!url) {
+      return _full;
+    }
+    return `${buildMarkdownLink(normalizeUrlForFeishu(url))}${trailing}`;
+  });
+
+  return convertedAutoLinks.replace(URL_RE, (raw, offset, input) => {
+    const { url, trailing } = splitTrailingPunctuation(raw);
+    if (!url) {
+      return raw;
+    }
+
+    // Do not rebuild existing markdown destinations, only normalize URL chars in-place.
+    const isMarkdownDestination = offset >= 2 && input.slice(offset - 2, offset) === "](";
+    const normalizedUrl = normalizeUrlForFeishu(url);
+    if (isMarkdownDestination) {
+      return `${normalizedUrl}${trailing}`;
+    }
+
+    return `${buildMarkdownLink(normalizedUrl)}${trailing}`;
+  });
+}
+
+function normalizeNonCodeSegments(text: string): string {
+  // Keep inline code untouched, normalize only plain markdown text.
+  return text
+    .split(INLINE_CODE_RE)
+    .map((segment, idx) => (idx % 2 === 1 && segment.startsWith("`") ? segment : wrapBareUrls(segment)))
+    .join("");
+}
+
+export function normalizeFeishuMarkdownLinks(text: string): string {
+  if (!text || (!text.includes("http://") && !text.includes("https://"))) {
+    return text;
+  }
+
+  return text
+    // Keep fenced code blocks untouched to avoid changing examples/snippets.
+    .split(FENCED_CODE_BLOCK_RE)
+    .map((block, idx) => (idx % 2 === 1 && block.startsWith("```") ? block : normalizeNonCodeSegments(block)))
+    .join("");
+}