@divyacon/piece-clickup 0.0.0-stage → 0.1.0

package/src/lib/actions/chat/get-channel.ts

@@ -0,0 +1,31 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi3, clickupCommon } from '../../common';
+import { clickupAuth } from '../../auth';
+import { getChannelOutputSchema } from '../../output-schemas';
+
+export const getClickupChannel = createAction({
+  auth: clickupAuth,
+  name: 'get_channel',
+  description: 'Gets a channel in a ClickUp workspace',
+  audience: 'both',
+  aiMetadata: { description: 'Read-only: fetch the details of a single ClickUp Chat channel by its workspace and channel IDs. Use when you already know the channel ID; to discover channels first, use Get Channels. Safe to call repeatedly.', idempotent: true },
+  displayName: 'Get Channel',
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    channel_id: clickupCommon.channel_id(),
+  },
+  
+  outputSchema: getChannelOutputSchema,
+  async run(configValue) {
+    const { workspace_id, channel_id } = configValue.propsValue;
+    const response = await callClickUpApi3(
+      HttpMethod.GET,
+      `workspaces/${workspace_id}/chat/channels/${channel_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined,
+      {}
+    );
+    return response.body;
+  },
+});

package/src/lib/actions/chat/get-channels.ts

@@ -0,0 +1,57 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  HttpMethod,
+  getAccessTokenOrThrow,
+  propsValidation,
+} from '@agnocon/pieces-common';
+import { callClickUpApi3, clickupCommon } from '../../common';
+import { clickupAuth } from '../../auth';
+import * as z from 'zod/mini'
+import { getChannelsOutputSchema } from '../../output-schemas';
+
+export const getClickupChannels = createAction({
+  auth: clickupAuth,
+  name: 'get_channels',
+  description: 'Gets all channels in a ClickUp workspace',
+  audience: 'both',
+  aiMetadata: { description: 'Read-only: list the Chat channels in a ClickUp workspace, optionally including hidden ones and capping the count (1-100). Use to discover channel IDs before reading or posting messages. Safe to call repeatedly.', idempotent: true },
+  displayName: 'Get Channels',
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    include_hidden: Property.Checkbox({
+      description: 'Include hidden channels',
+      displayName: 'Include Hidden',
+      required: false,
+      defaultValue: false,
+    }),
+    limit: Property.Number({
+      description: 'Limit the number of channels returned',
+      displayName: 'Limit',
+      required: false,
+      defaultValue: 50,
+    }),
+  },
+
+  outputSchema: getChannelsOutputSchema,
+  async run(configValue) {
+    await propsValidation.validateZod(configValue.propsValue, {
+      limit: z.number().check(z.minimum(0), z.maximum(100, 'You can fetch between 1 and 100 messages')),
+    });
+
+    const { workspace_id, include_hidden, limit } = configValue.propsValue;
+
+    const response = await callClickUpApi3(
+      HttpMethod.GET,
+      `workspaces/${workspace_id}/chat/channels`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined,
+      {
+        limit,
+        is_follower: false,
+        include_hidden,
+      }
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/chat/get-message-reactions.ts

@@ -0,0 +1,36 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { Property } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi3, clickupCommon } from '../../common';
+import { clickupAuth } from '../../auth';
+import { getMessageReactionsOutputSchema } from '../../output-schemas';
+
+export const getClickupMessageReactions = createAction({
+  auth: clickupAuth,
+  name: 'get_message_reactions',
+  description: 'Gets the reactions of a message in a ClickUp channel',
+  audience: 'both',
+  aiMetadata: { description: 'Read-only: list the emoji reactions on a specific Chat message in a ClickUp workspace, given the workspace and message IDs. Use to inspect who reacted and with what; does not modify the message. Safe to call repeatedly.', idempotent: true },
+  displayName: 'Get Message Reactions',
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    message_id: Property.ShortText({
+      description: 'ID of the message to get reactions for',
+      displayName: 'Message ID',
+      required: true,
+    }),
+  },
+
+  outputSchema: getMessageReactionsOutputSchema,
+  async run(configValue) {
+    const { workspace_id, message_id } = configValue.propsValue;
+    const response = await callClickUpApi3(
+      HttpMethod.GET,
+      `workspaces/${workspace_id}/chat/messages/${message_id}/reactions`,
+      getAccessTokenOrThrow(configValue.auth),
+      {},
+      {}
+    );
+    return response.body;
+  },
+});

package/src/lib/actions/chat/get-message-replies.ts

@@ -0,0 +1,36 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { Property } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi3, clickupCommon } from '../../common';
+import { clickupAuth } from '../../auth';
+import { messageRepliesOutputSchema } from '../../output-schemas';
+
+export const getClickupMessageReplies = createAction({
+  auth: clickupAuth,
+  name: 'get_message_replies',
+  description: 'Gets the replies of a message in a ClickUp channel',
+  audience: 'both',
+  aiMetadata: { description: 'Read-only: retrieve the threaded replies to a specific Chat message in a ClickUp workspace, given the workspace and message IDs. Use to read a reply thread; does not post anything. Safe to call repeatedly.', idempotent: true },
+  displayName: 'Get Message Replies',
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    message_id: Property.ShortText({
+      description: 'ID of the message to get replies for',
+      displayName: 'Message ID',
+      required: true,
+    }),
+  },
+
+  outputSchema: messageRepliesOutputSchema,
+  async run(configValue) {
+    const { workspace_id, message_id } = configValue.propsValue;
+    const response = await callClickUpApi3(
+      HttpMethod.GET,
+      `workspaces/${workspace_id}/chat/messages/${message_id}/replies`,
+      getAccessTokenOrThrow(configValue.auth),
+      {},
+      {}
+    );
+    return response.body;
+  },
+});

package/src/lib/actions/chat/update-message.ts

@@ -0,0 +1,55 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { Property } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi3, clickupCommon } from '../../common';
+import { clickupAuth } from '../../auth';
+import { messageOutputSchema } from '../../output-schemas';
+
+export const updateClickupMessage = createAction({
+  auth: clickupAuth,
+  name: 'update_message',
+  description: 'Updates a message in a ClickUp channel',
+  audience: 'both',
+  aiMetadata: { description: 'Replace the content of an existing ClickUp chat message, identified by its message ID, within a workspace. Pick this to edit a message that was already posted; you must already know the message ID and supply the new content plus its format (Markdown or plain text). Overwrites the message content rather than appending, so re-running with the same content is effectively idempotent.', idempotent: false },
+  displayName: 'Update Message',
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    message_id: Property.ShortText({
+      description: 'ID of the message to update',
+      displayName: 'Message ID',
+      required: true,
+    }),
+    content: Property.LongText({
+      description: 'Content of the message',
+      displayName: 'Message Content',
+      required: true,
+    }),
+    content_format: Property.StaticDropdown({
+      description: 'Format of the message content',
+      displayName: 'Message Content Format',
+      required: true,
+      options: {
+        options: [
+          { label: 'Markdown', value: 'text/md' },
+          { label: 'Plain Text', value: 'text/plain' },
+        ],
+      },
+    }),
+  },
+
+  outputSchema: messageOutputSchema,
+  async run(configValue) {
+    const { workspace_id,  message_id, content, content_format } = configValue.propsValue;
+    const response = await callClickUpApi3(
+      HttpMethod.PATCH,
+      `workspaces/${workspace_id}/chat/messages/${message_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      {
+        content,
+        content_format,
+      },
+      {}
+    );
+    return response.body;
+  },
+});

package/src/lib/actions/checklists/create-checklist-item.ts

@@ -0,0 +1,54 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { checklistOutputSchema } from '../../output-schemas';
+
+export const clickupCreateChecklistItem = createAction({
+  auth: clickupAuth,
+  name: 'clickup_create_checklist_item',
+  description: 'Add an item to a ClickUp checklist',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Add a line item to an existing ClickUp checklist, identified by its checklist ID (obtained from Create Checklist). Optionally assign the item to a user. Each call adds a separate item, so it is not idempotent.',
+    idempotent: false,
+  },
+  displayName: 'Create Checklist Item',
+  outputSchema: checklistOutputSchema,
+  props: {
+    checklist_id: Property.ShortText({
+      description:
+        'The ID of the checklist to add the item to (from Create Checklist)',
+      displayName: 'Checklist ID',
+      required: true,
+    }),
+    name: Property.ShortText({
+      description: 'The text of the checklist item',
+      displayName: 'Item Name',
+      required: true,
+    }),
+    assignee: Property.Number({
+      description: 'The user ID to assign this checklist item to',
+      displayName: 'Assignee',
+      required: false,
+    }),
+  },
+  async run(configValue) {
+    const { checklist_id, name, assignee } = configValue.propsValue;
+
+    const body: Record<string, unknown> = { name };
+    if (assignee !== undefined && assignee !== null) {
+      body['assignee'] = assignee;
+    }
+
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `checklist/${checklist_id}/checklist_item`,
+      getAccessTokenOrThrow(configValue.auth),
+      body
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/checklists/create-checklist.ts

@@ -0,0 +1,42 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { checklistOutputSchema } from '../../output-schemas';
+
+export const clickupCreateChecklist = createAction({
+  auth: clickupAuth,
+  name: 'clickup_create_checklist',
+  description: 'Create a new checklist on a ClickUp task',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Create a new checklist on a ClickUp task. The response contains the new checklist ID, which you then pass to Create Checklist Item to add items. Each call creates a separate checklist, so it is not idempotent.',
+    idempotent: false,
+  },
+  displayName: 'Create Checklist',
+  outputSchema: checklistOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    list_id: clickupCommon.list_id(),
+    task_id: clickupCommon.task_id(),
+    name: Property.ShortText({
+      description: 'The name of the checklist',
+      displayName: 'Checklist Name',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { task_id, name } = configValue.propsValue;
+
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `task/${task_id}/checklist`,
+      getAccessTokenOrThrow(configValue.auth),
+      { name }
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/checklists/delete-checklist-item.ts

@@ -0,0 +1,41 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupDeleteChecklistItem = createAction({
+  auth: clickupAuth,
+  name: 'clickup_delete_checklist_item',
+  description: 'Delete a single item from a ClickUp checklist',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Delete one item from a ClickUp checklist, identified by its checklist ID and checklist item ID. To remove the whole checklist at once, use Delete Checklist instead. Each call targets a specific item ID that no longer exists after deletion, so it is not idempotent on retry.',
+    idempotent: false,
+  },
+  displayName: 'Delete Checklist Item',
+  props: {
+    checklist_id: Property.ShortText({
+      description: 'The ID of the parent checklist (from Create Checklist)',
+      displayName: 'Checklist ID',
+      required: true,
+    }),
+    checklist_item_id: Property.ShortText({
+      description: 'The ID of the checklist item to delete',
+      displayName: 'Checklist Item ID',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { checklist_id, checklist_item_id } = configValue.propsValue;
+
+    const response = await callClickUpApi(
+      HttpMethod.DELETE,
+      `checklist/${checklist_id}/checklist_item/${checklist_item_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/checklists/delete-checklist.ts

@@ -0,0 +1,36 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupDeleteChecklist = createAction({
+  auth: clickupAuth,
+  name: 'clickup_delete_checklist',
+  description: 'Delete a checklist from a ClickUp task',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Delete an entire ClickUp checklist (and all its items) by its checklist ID. To remove a single item instead, use Delete Checklist Item. Deleting an already-removed checklist is treated as a no-op, so this is safe to retry.',
+    idempotent: true,
+  },
+  displayName: 'Delete Checklist',
+  props: {
+    checklist_id: Property.ShortText({
+      description: 'The ID of the checklist to delete (from Create Checklist)',
+      displayName: 'Checklist ID',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { checklist_id } = configValue.propsValue;
+
+    const response = await callClickUpApi(
+      HttpMethod.DELETE,
+      `checklist/${checklist_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/checklists/update-checklist-item.ts

@@ -0,0 +1,79 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { checklistOutputSchema } from '../../output-schemas';
+
+export const clickupUpdateChecklistItem = createAction({
+  auth: clickupAuth,
+  name: 'clickup_update_checklist_item',
+  description: 'Edit, resolve, or nest a ClickUp checklist item',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Update a single ClickUp checklist item: rename it, mark it resolved/unresolved, reassign it, or nest it under another item as a parent. Requires the checklist ID and the checklist item ID. This sets the item to the supplied end state, so repeating the same update is idempotent.',
+    idempotent: true,
+  },
+  displayName: 'Update Checklist Item',
+  outputSchema: checklistOutputSchema,
+  props: {
+    checklist_id: Property.ShortText({
+      description: 'The ID of the parent checklist (from Create Checklist)',
+      displayName: 'Checklist ID',
+      required: true,
+    }),
+    checklist_item_id: Property.ShortText({
+      description: 'The ID of the checklist item to update',
+      displayName: 'Checklist Item ID',
+      required: true,
+    }),
+    name: Property.ShortText({
+      description: 'The new text of the checklist item',
+      displayName: 'Item Name',
+      required: false,
+    }),
+    resolved: Property.Checkbox({
+      description: 'Whether the checklist item is resolved (checked)',
+      displayName: 'Resolved',
+      required: false,
+    }),
+    assignee: Property.Number({
+      description: 'The user ID to assign this checklist item to',
+      displayName: 'Assignee',
+      required: false,
+    }),
+    parent: Property.ShortText({
+      description:
+        'The ID of another checklist item to nest this one under as a child',
+      displayName: 'Parent Item ID',
+      required: false,
+    }),
+  },
+  async run(configValue) {
+    const { checklist_id, checklist_item_id, name, resolved, assignee, parent } =
+      configValue.propsValue;
+
+    const body: Record<string, unknown> = {};
+    if (name !== undefined && name !== null && name !== '') {
+      body['name'] = name;
+    }
+    if (resolved !== undefined && resolved !== null) {
+      body['resolved'] = resolved;
+    }
+    if (assignee !== undefined && assignee !== null) {
+      body['assignee'] = assignee;
+    }
+    if (parent !== undefined && parent !== null && parent !== '') {
+      body['parent'] = parent;
+    }
+
+    const response = await callClickUpApi(
+      HttpMethod.PUT,
+      `checklist/${checklist_id}/checklist_item/${checklist_item_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      body
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/checklists/update-checklist.ts

@@ -0,0 +1,57 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { checklistOutputSchema } from '../../output-schemas';
+
+export const clickupUpdateChecklist = createAction({
+  auth: clickupAuth,
+  name: 'clickup_update_checklist',
+  description: 'Rename or reposition a checklist in ClickUp',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Rename a ClickUp checklist or change its position, identified by its checklist ID (obtained from Create Checklist or the task data). To edit the items inside it use Update Checklist Item instead. This sets the checklist to the supplied end state, so repeating the same update is idempotent.',
+    idempotent: true,
+  },
+  displayName: 'Update Checklist',
+  outputSchema: checklistOutputSchema,
+  props: {
+    checklist_id: Property.ShortText({
+      description: 'The ID of the checklist to update (from Create Checklist)',
+      displayName: 'Checklist ID',
+      required: true,
+    }),
+    name: Property.ShortText({
+      description: 'The new name of the checklist',
+      displayName: 'Checklist Name',
+      required: false,
+    }),
+    position: Property.Number({
+      description:
+        'The zero-based position of the checklist relative to other checklists on the task',
+      displayName: 'Position',
+      required: false,
+    }),
+  },
+  async run(configValue) {
+    const { checklist_id, name, position } = configValue.propsValue;
+
+    const body: Record<string, unknown> = {};
+    if (name !== undefined && name !== null && name !== '') {
+      body['name'] = name;
+    }
+    if (position !== undefined && position !== null) {
+      body['position'] = position;
+    }
+
+    const response = await callClickUpApi(
+      HttpMethod.PUT,
+      `checklist/${checklist_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      body
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/comments/clickup-create-task-comment.ts

@@ -0,0 +1,68 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { createTaskCommentOutputSchema } from '../../output-schemas';
+
+export const clickupCreateTaskComment = createAction({
+  auth: clickupAuth,
+  name: 'clickup_create_task_comment',
+  description: 'Creates a comment on a task in ClickUp',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Post a new comment on a ClickUp task identified by its task ID. Use this to add a discussion note or @-style update to a task; to read existing comments use Get Task Comments, and to reply within a thread use Create Threaded Comment. Each call adds a distinct comment, so it is not idempotent; if no assignee is given the comment is attributed to the authenticated user.',
+    idempotent: false,
+  },
+  displayName: 'Create Task Comment',
+  outputSchema: createTaskCommentOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    list_id: clickupCommon.list_id(),
+    task_id: clickupCommon.task_id(),
+    comment: Property.LongText({
+      description: 'Comment to make on the task',
+      displayName: 'Comment',
+      required: true,
+    }),
+    assignee_id: clickupCommon.single_assignee_id(
+      false,
+      'Assignee Id',
+      'ID of assignee for Task Comment'
+    ),
+  },
+  async run(configValue) {
+    const { task_id, comment } = configValue.propsValue;
+
+    let assignee_id = configValue.propsValue.assignee_id;
+
+    if (!assignee_id) {
+      const user_request = await callClickUpApi(
+        HttpMethod.GET,
+        `user`,
+        getAccessTokenOrThrow(configValue.auth),
+        {}
+      );
+
+      if (user_request.body['user'] === undefined) {
+        throw 'Please connect to your ClickUp account';
+      }
+
+      assignee_id = user_request.body['user']['id'];
+    }
+
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `task/${task_id}/comment`,
+      getAccessTokenOrThrow(configValue.auth),
+      {
+        comment_text: comment,
+        assignee: assignee_id,
+        notify_all: true,
+      }
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/comments/clickup-delete-comment.ts

@@ -0,0 +1,37 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupDeleteComment = createAction({
+  auth: clickupAuth,
+  name: 'clickup_delete_comment',
+  description: 'Delete a comment in ClickUp',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Delete a ClickUp comment identified by its comment ID. Obtain the comment ID from Get Task Comments or Get Threaded Comments. Removing an already-deleted comment is treated as a no-op, so this is safe to retry.',
+    idempotent: true,
+  },
+  displayName: 'Delete Comment',
+  props: {
+    comment_id: Property.ShortText({
+      description:
+        'The ID of the comment to delete (from Get Task Comments or Get Threaded Comments)',
+      displayName: 'Comment ID',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { comment_id } = configValue.propsValue;
+
+    const response = await callClickUpApi(
+      HttpMethod.DELETE,
+      `comment/${comment_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/comments/clickup-get-task-comments.ts

@@ -0,0 +1,37 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { getTaskCommentsOutputSchema } from '../../output-schemas';
+
+export const clickupGetTaskComments = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_task_comments',
+  description: 'Gets comments from a task in ClickUp',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Read-only: retrieve the comments on a ClickUp task by its task ID. Use to review discussion or activity on a known task, or to obtain a comment ID to feed Update Comment, Delete Comment, or Create Threaded Comment. Does not modify anything and is safe to call repeatedly.',
+    idempotent: true,
+  },
+  displayName: 'Get Task Comments',
+  outputSchema: getTaskCommentsOutputSchema,
+  props: {
+    task_id: Property.ShortText({
+      description: 'The ID of the task to get',
+      displayName: 'Task ID',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { task_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `task/${task_id}/comment`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});