@divyacon/piece-clickup 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,63 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupUpdateComment = createAction({
+  auth: clickupAuth,
+  name: 'clickup_update_comment',
+  description: 'Update an existing comment in ClickUp',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Edit a ClickUp comment identified by its comment ID: change its text, reassign it, or mark it resolved/unresolved. Obtain the comment ID from Get Task Comments or Get Threaded Comments. This sets the comment to the supplied end state, so repeating the same update is idempotent.',
+    idempotent: true,
+  },
+  displayName: 'Update Comment',
+  props: {
+    comment_id: Property.ShortText({
+      description:
+        'The ID of the comment to update (from Get Task Comments or Get Threaded Comments)',
+      displayName: 'Comment ID',
+      required: true,
+    }),
+    comment_text: Property.LongText({
+      description: 'The new text of the comment',
+      displayName: 'Comment Text',
+      required: true,
+    }),
+    assignee: Property.Number({
+      description: 'The user ID to assign the comment to',
+      displayName: 'Assignee',
+      required: false,
+    }),
+    resolved: Property.Checkbox({
+      description: 'Whether the comment is resolved',
+      displayName: 'Resolved',
+      required: false,
+    }),
+  },
+  async run(configValue) {
+    const { comment_id, comment_text, assignee, resolved } =
+      configValue.propsValue;
+
+    const body: Record<string, unknown> = {
+      comment_text,
+    };
+    if (assignee !== undefined && assignee !== null) {
+      body['assignee'] = assignee;
+    }
+    if (resolved !== undefined && resolved !== null) {
+      body['resolved'] = resolved;
+    }
+
+    const response = await callClickUpApi(
+      HttpMethod.PUT,
+      `comment/${comment_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      body
+    );
+
+    return response.body;
+  },
+});

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

@@ -0,0 +1,64 @@
+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 createClickupTaskComment = createAction({
+  auth: clickupAuth,
+  name: 'create_task_comments',
+  description: 'Creates a comment on a task in ClickUp',
+  audience: 'human',
+  aiMetadata: { description: 'Post a new comment on a ClickUp task and notify the workspace. Each call adds a distinct comment, so repeated calls create duplicates (not idempotent). If no assignee is given, the comment is attributed to the authenticated user.', idempotent: false },
+  displayName: 'Create Task Comment',
+  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'
+    ),
+  },
+  outputSchema: createTaskCommentOutputSchema,
+  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/get-task-comments.ts

@@ -0,0 +1,33 @@
+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 getClickupTaskComments = createAction({
+  auth: clickupAuth,
+  name: 'get_task_comments',
+  description: 'Gets comments from a task in ClickUp',
+  audience: 'human',
+  aiMetadata: { description: 'Read-only: retrieve the existing comments on a ClickUp task by its task ID. Use to review discussion or activity on a known task; does not create or modify anything. Safe to call repeatedly.', idempotent: true },
+  displayName: 'Get Task Comments',
+  props: {
+    task_id: Property.ShortText({
+      description: 'The ID of the task to get',
+      displayName: 'Task ID',
+      required: true,
+    }),
+  },
+  outputSchema: getTaskCommentsOutputSchema,
+  async run(configValue) {
+    const { task_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `/task/${task_id}/comment`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/custom-fields/get-accessible-custom-fields-ai.ts

@@ -0,0 +1,31 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, listAccessibleCustomFields } from '../../common';
+import { clickupAuth } from '../../auth';
+import { accessibleCustomFieldsArrayOutputSchema } from '../../output-schemas';
+
+export const clickupGetAccessibleCustomFields = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_accessible_custom_fields',
+  displayName: 'Get Accessible Custom Fields',
+  description: 'View the Custom Fields available on tasks in a specific List.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Read-only: list the custom fields defined for tasks in a given ClickUp list, including each field ID, type, and configuration. Use this to discover valid field IDs and their expected value formats before calling Set Custom Field Value or Remove Custom Field Value on a task. Safe to call repeatedly (idempotent).',
+    idempotent: true,
+  },
+  outputSchema: accessibleCustomFieldsArrayOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(true),
+    space_id: clickupCommon.space_id(true),
+    list_id: clickupCommon.list_id(true),
+  },
+  async run(configValue) {
+    const { list_id } = configValue.propsValue;
+    const auth = getAccessTokenOrThrow(configValue.auth);
+
+    return (await listAccessibleCustomFields(auth, list_id as unknown as string))
+      .fields;
+  },
+});

package/src/lib/actions/custom-fields/get-accessible-custom-fields.ts

@@ -0,0 +1,26 @@
+import { createAction } from "@agnocon/pieces-framework";
+import { getAccessTokenOrThrow } from "@agnocon/pieces-common";
+import { clickupCommon, listAccessibleCustomFields } from "../../common"
+import { clickupAuth } from '../../auth';
+import { accessibleCustomFieldsOutputSchema } from '../../output-schemas';
+
+export const getClickupAccessibleCustomFields = createAction({
+  auth: clickupAuth,
+  name: 'get_accessible_custom_fields',
+  displayName: 'Get Accessible Custom Fields',
+  description: 'View the Custom Fields available on tasks in a specific List.',
+  audience: 'human',
+  aiMetadata: { description: 'Read-only: list the custom fields defined for tasks in a given ClickUp list, including each field ID, type, and configuration. Use this to discover valid field IDs before setting a custom field value on a task. Safe to call repeatedly.', idempotent: true },
+  props: {
+    workspace_id: clickupCommon.workspace_id(true),
+    space_id: clickupCommon.space_id(true),
+    list_id: clickupCommon.list_id(true)
+  },
+  outputSchema: accessibleCustomFieldsOutputSchema,
+  async run(configValue) {
+    const { list_id } = configValue.propsValue;
+    const auth = getAccessTokenOrThrow(configValue.auth)
+
+    return (await listAccessibleCustomFields(auth, list_id as unknown as string)).fields
+  }
+})

package/src/lib/actions/custom-fields/set-custom-fields-value.ts

@@ -0,0 +1,37 @@
+import { Property, createAction } from "@agnocon/pieces-framework";
+import { HttpMethod, getAccessTokenOrThrow } from "@agnocon/pieces-common";
+import { callClickUpApi, clickupCommon } from "../../common"
+import { clickupAuth } from '../../auth';
+
+export const setClickupCustomFieldValue = createAction({
+  auth: clickupAuth,
+  name: 'set_custom_fields_value',
+  displayName: 'Set Custom Field Value',
+  description: 'Add data to a Custom field on a task.',
+  audience: 'both',
+  aiMetadata: { description: 'Set the value of a specific custom field on a ClickUp task, given the task ID and field ID. This overwrites the field with the supplied value, so repeating with the same value leaves the task in the same state (upsert by field). Use get-accessible-custom-fields first to find the field ID and its expected value format.', idempotent: true },
+  props: {
+    workspace_id: clickupCommon.workspace_id(true),
+    space_id: clickupCommon.space_id(true),
+    list_id: clickupCommon.list_id(false),
+    task_id: clickupCommon.task_id(true),
+    field_id: clickupCommon.field_id(true),
+    value: Property.LongText({
+      displayName: "Value",
+      description: "The new value to be set",
+      required: true
+    })
+  },
+  async run(configValue) {
+    const { field_id, task_id, value } = configValue.propsValue;
+
+    const response = await callClickUpApi<Record<string, unknown>>(
+      HttpMethod.POST,
+      `task/${task_id}/field/${field_id}`, 
+      getAccessTokenOrThrow(configValue.auth), 
+      { value: value }
+    );
+
+    return response.body
+  }
+})

package/src/lib/actions/folders/ai-create-folder.ts

@@ -0,0 +1,41 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { folderOutputSchema } from '../../output-schemas';
+
+export const clickupCreateFolder = createAction({
+  auth: clickupAuth,
+  name: 'clickup_create_folder',
+  description: 'Create a new folder in a ClickUp space',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Create a new folder inside a ClickUp space to group lists. Pick this to add an organizational container under a space; to add a list directly, use Create Folderless List. Each call creates a new folder even with the same name, so retries duplicate it.',
+    idempotent: false,
+  },
+  displayName: 'Create Folder',
+  outputSchema: folderOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    name: Property.ShortText({
+      description: 'The name of the folder to create',
+      displayName: 'Folder Name',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { space_id, name } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `space/${space_id}/folder`,
+      getAccessTokenOrThrow(configValue.auth),
+      {
+        name,
+      }
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/folders/ai-delete-folder.ts

@@ -0,0 +1,35 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupDeleteFolder = createAction({
+  auth: clickupAuth,
+  name: 'clickup_delete_folder',
+  description: 'Delete a ClickUp folder by its ID',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Permanently delete a ClickUp folder (and all lists and tasks it contains) by folder ID. This is destructive and cannot be undone, so confirm the ID before calling. Resolve the folder ID with Get Folders for the intended space first — do not reuse a stale or copied ID, as any folder the connection can access will be deleted. Deleting an already-deleted folder fails rather than succeeding, so treat it as non-idempotent.',
+    idempotent: false,
+  },
+  displayName: 'Delete Folder',
+  props: {
+    folder_id: Property.ShortText({
+      description: 'The ID of the folder to delete',
+      displayName: 'Folder ID',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { folder_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.DELETE,
+      `folder/${folder_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/folders/ai-get-folder.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 { folderOutputSchema } from '../../output-schemas';
+
+export const clickupGetFolder = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_folder',
+  description: 'Get a single ClickUp folder by its ID',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Read-only: fetch the details of one ClickUp folder by folder ID. Use when you already know the folder ID; to discover folder IDs first, use Get Folders. Safe to call repeatedly.',
+    idempotent: true,
+  },
+  displayName: 'Get Folder',
+  outputSchema: folderOutputSchema,
+  props: {
+    folder_id: Property.ShortText({
+      description: 'The ID of the folder to get',
+      displayName: 'Folder ID',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { folder_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `folder/${folder_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/folders/ai-get-folders.ts

@@ -0,0 +1,34 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { getFoldersOutputSchema } from '../../output-schemas';
+
+export const clickupGetFolders = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_folders',
+  description: 'List all folders in a ClickUp space',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Read-only: list every folder in a ClickUp space, returning their IDs and names. Use to discover folder IDs before acting on a folder or creating a list inside one. Safe to call repeatedly.',
+    idempotent: true,
+  },
+  displayName: 'Get Folders',
+  outputSchema: getFoldersOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+  },
+  async run(configValue) {
+    const { space_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `space/${space_id}/folder`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/folders/ai-update-folder.ts

@@ -0,0 +1,44 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { folderOutputSchema } from '../../output-schemas';
+
+export const clickupUpdateFolder = createAction({
+  auth: clickupAuth,
+  name: 'clickup_update_folder',
+  description: 'Rename an existing ClickUp folder',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Rename an existing ClickUp folder by folder ID. Pick this to change a folder you already have the ID for; use Create Folder to make a new one. Re-running with the same name yields the same end state.',
+    idempotent: true,
+  },
+  displayName: 'Update Folder',
+  outputSchema: folderOutputSchema,
+  props: {
+    folder_id: Property.ShortText({
+      description: 'The ID of the folder to update',
+      displayName: 'Folder ID',
+      required: true,
+    }),
+    name: Property.ShortText({
+      description: 'The new name for the folder',
+      displayName: 'Folder Name',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { folder_id, name } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.PUT,
+      `folder/${folder_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      {
+        name,
+      }
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/lists/ai-create-folderless-list.ts

@@ -0,0 +1,41 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { listOutputSchema } from '../../output-schemas';
+
+export const clickupCreateFolderlessList = createAction({
+  auth: clickupAuth,
+  name: 'clickup_create_folderless_list',
+  description: 'Create a new list directly under a ClickUp space',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Create a new list directly under a ClickUp space, not inside a folder. Pick this for a top-level list in a space; use Create List (in Folder) when the list belongs to a folder. Each call creates a new list even with the same name, so retries duplicate it.',
+    idempotent: false,
+  },
+  displayName: 'Create Folderless List',
+  outputSchema: listOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    name: Property.ShortText({
+      description: 'The name of the list to create',
+      displayName: 'List Name',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { space_id, name } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `space/${space_id}/list`,
+      getAccessTokenOrThrow(configValue.auth),
+      {
+        name,
+      }
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/lists/ai-create-list.ts

@@ -0,0 +1,48 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { listOutputSchema } from '../../output-schemas';
+
+export const clickupCreateList = createAction({
+  auth: clickupAuth,
+  name: 'clickup_create_list',
+  description: 'Create a new list inside a ClickUp folder',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Create a new list inside a specific ClickUp folder. Pick this when the list should live under a folder; use Create Folderless List when it should sit directly under a space. Each call creates a new list even with the same name, so retries duplicate it.',
+    idempotent: false,
+  },
+  displayName: 'Create List (in Folder)',
+  outputSchema: listOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    folder_id: clickupCommon.folder_id(true),
+    name: Property.ShortText({
+      description: 'The name of the list to create',
+      displayName: 'List Name',
+      required: true,
+    }),
+    content: Property.LongText({
+      description: 'Optional description/content for the list',
+      displayName: 'Content',
+      required: false,
+    }),
+  },
+  async run(configValue) {
+    const { folder_id, name, content } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `folder/${folder_id}/list`,
+      getAccessTokenOrThrow(configValue.auth),
+      {
+        name,
+        content,
+      }
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/lists/ai-delete-list.ts

@@ -0,0 +1,35 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupDeleteList = createAction({
+  auth: clickupAuth,
+  name: 'clickup_delete_list',
+  description: 'Delete a ClickUp list by its ID',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Permanently delete a ClickUp list (and all tasks it contains) by list ID. This is destructive and cannot be undone, so confirm the ID before calling. Resolve the list ID with Get Folder Lists / Get Folderless Lists for the intended folder/space first — do not reuse a stale or copied ID, as any list the connection can access will be deleted. Deleting an already-deleted list fails rather than succeeding, so treat it as non-idempotent.',
+    idempotent: false,
+  },
+  displayName: 'Delete List',
+  props: {
+    list_id: Property.ShortText({
+      description: 'The ID of the list to delete',
+      displayName: 'List ID',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { list_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.DELETE,
+      `list/${list_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/lists/ai-get-folder-lists.ts

@@ -0,0 +1,35 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { getListsOutputSchema } from '../../output-schemas';
+
+export const clickupGetFolderLists = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_folder_lists',
+  description: 'List all lists inside a ClickUp folder',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Read-only: list every list inside a specific ClickUp folder, returning their IDs and names. Use to discover list IDs within a folder before acting on a list; for lists that sit directly under a space, use Get Folderless Lists instead. Safe to call repeatedly.',
+    idempotent: true,
+  },
+  displayName: 'Get Folder Lists',
+  outputSchema: getListsOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    folder_id: clickupCommon.folder_id(true),
+  },
+  async run(configValue) {
+    const { folder_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `folder/${folder_id}/list`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/lists/ai-get-folderless-lists.ts

@@ -0,0 +1,34 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { getListsOutputSchema } from '../../output-schemas';
+
+export const clickupGetFolderlessLists = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_folderless_lists',
+  description: 'List the folderless lists directly under a ClickUp space',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Read-only: list the lists that sit directly under a ClickUp space (not inside any folder), returning their IDs and names. Use to discover top-level list IDs in a space; for lists inside a folder, use Get Folder Lists instead. Safe to call repeatedly.',
+    idempotent: true,
+  },
+  displayName: 'Get Folderless Lists',
+  outputSchema: getListsOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+  },
+  async run(configValue) {
+    const { space_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `space/${space_id}/list`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});