Skip to main content
Glama

getTasksByProjectId

Retrieve all tasks for a specific project in Teamwork by providing the project ID.

Instructions

Get all tasks from a specific project in Teamwork

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
projectIdYesThe ID of the project to get tasks from

Implementation Reference

  • Handler function that processes the 'getTasksByProjectId' tool invocation. Extracts projectId from input, calls the service layer, and returns the tasks data as a text content response.
    export async function handleGetTasksByProjectId(input: any) {
      logger.info('Calling teamworkService.getTasksByProjectId()');
      logger.info(`Project ID: ${input?.projectId}`);
      
      try {
        const projectId = String(input?.projectId);
        if (!projectId) {
          throw new Error("Project ID is required");
        }
        
        const tasks = await teamworkService.getTasksByProjectId(projectId);
        logger.info(`Tasks response received for project ID: ${projectId}`);
        
        return {
          content: [{
            type: "text",
            text: JSON.stringify(tasks, null, 2)
          }]
        };
      } catch (error: any) {
        return createErrorResponse(error, 'Retrieving tasks for project');
      }
    } 
  • Tool definition including name ('getTasksByProjectId'), description, and inputSchema requiring a projectId (integer). Also contains annotations metadata.
    export const getTasksByProjectIdDefinition = {
      name: "getTasksByProjectId",
      description: "Get all tasks from a specific project in Teamwork",
      inputSchema: {
        type: "object",
        properties: {
          projectId: {
            type: "integer",
            description: "The ID of the project to get tasks from"
          }
        },
        required: ["projectId"]
      },
      annotations: {
        title: "Get Tasks by Project ID",
        readOnlyHint: false,
        destructiveHint: false,
        openWorldHint: false
      }
    };
  • Import and registration of the tool definition and handler in the central tools index. Line 13 imports them, line 70 registers in toolPairs array, line 118 re-exports the handler.
    import { getTasksByProjectIdDefinition as getTasksByProjectId, handleGetTasksByProjectId } from './tasks/getTasksByProjectId.js';
    import { getTasksByTaskListIdDefinition as getTasksByTaskListId, handleGetTasksByTaskListId } from './tasks/getTasksByTaskListId.js';
    import { getTaskListsByProjectIdDefinition as getTaskListsByProjectId, handleGetTaskListsByProjectId } from './tasks/getTaskListsByProjectId.js';
    import { getTaskByIdDefinition as getTaskById, handleGetTaskById } from './tasks/getTaskById.js';
    import { createTaskDefinition as createTask, handleCreateTask } from './tasks/createTask.js';
    import { createSubTaskDefinition as createSubTask, handleCreateSubTask } from './tasks/createSubTask.js';
    import { updateTaskDefinition as updateTask, handleUpdateTask } from './tasks/updateTask.js';
    import { deleteTaskDefinition as deleteTask, handleDeleteTask } from './tasks/deleteTask.js';
    import { getTasksMetricsCompleteDefinition as getTasksMetricsComplete, handleGetTasksMetricsComplete } from './tasks/getTasksMetricsComplete.js';
    import { getTasksMetricsLateDefinition as getTasksMetricsLate, handleGetTasksMetricsLate } from './tasks/getTasksMetricsLate.js';
    import { getTaskSubtasksDefinition as getTaskSubtasks, handleGetTaskSubtasks } from './tasks/getTaskSubtasks.js';
    import { getTaskCommentsDefinition as getTaskComments, handleGetTaskComments } from './tasks/getTaskComments.js';
    
    // Comments
    import { createCommentDefinition as createComment, handleCreateComment } from './comments/createComment.js';
    
    // People
    import { getPeopleDefinition as getPeople, handleGetPeople } from './people/getPeople.js';
    import { getPersonByIdDefinition as getPersonById, handleGetPersonById } from './people/getPersonById.js';
    import { getProjectPeopleDefinition as getProjectPeople, handleGetProjectPeople } from './people/getProjectPeople.js';
    import { addPeopleToProjectDefinition as addPeopleToProject, handleAddPeopleToProject } from './people/addPeopleToProject.js';
    import { deletePersonDefinition as deletePerson, handleDeletePerson } from './people/deletePerson.js';
    import { updatePersonDefinition as updatePerson, handleUpdatePerson } from './people/updatePerson.js';
    
    // Companies
    import { createCompanyDefinition as createCompany, handleCreateCompany } from './companies/createCompany.js';
    import { updateCompanyDefinition as updateCompany, handleUpdateCompany } from './companies/updateCompany.js';
    import { deleteCompanyDefinition as deleteCompany, handleDeleteCompany } from './companies/deleteCompany.js';
    import { getCompaniesDefinition as getCompanies, handleGetCompanies } from './companies/getCompanies.js';
    import { getCompanyByIdDefinition as getCompanyById, handleGetCompanyById } from './companies/getCompanyById.js';
    
    // Reporting
    import { getProjectsPeopleMetricsPerformanceDefinition as getProjectsPeopleMetricsPerformance, handleGetProjectsPeopleMetricsPerformance } from './people/getPeopleMetricsPerformance.js';
    import { getProjectsPeopleUtilizationDefinition as getProjectsPeopleUtilization, handleGetProjectsPeopleUtilization } from './people/getPeopleUtilization.js';
    import { getProjectPersonDefinition as getProjectPerson, handleGetProjectPerson } from './people/getProjectPerson.js';
    import { getProjectsReportingUserTaskCompletionDefinition as getProjectsReportingUserTaskCompletion, handleGetProjectsReportingUserTaskCompletion } from './reporting/getUserTaskCompletion.js';
    import { getProjectsReportingUtilizationDefinition as getProjectsReportingUtilization, handleGetProjectsReportingUtilization } from './people/getUtilization.js';
    
    // Time-related imports
    import { getTimeDefinition as getTime, handleGetTime } from './time/getTime.js';
    import { getProjectsAllocationsTimeDefinition as getAllocationTime, handleGetProjectsAllocationsTime } from './time/getAllocationTime.js';
    
    // Core
    import { getTimezonesDefinition as getTimezones, handleGetTimezones } from './core/getTimezones.js';
    
    // Define a structure that pairs tool definitions with their handlers
    interface ToolPair {
      definition: any;
      handler: Function;
    }
    
    // Create an array of tool pairs
    const toolPairs: ToolPair[] = [
      { definition: getProjects, handler: handleGetProjects },
      { definition: getCurrentProject, handler: handleGetCurrentProject },
      { definition: createProject, handler: handleCreateProject },
      { definition: getTasks, handler: handleGetTasks },
      { definition: getTasksByProjectId, handler: handleGetTasksByProjectId },
  • Import and re-export of the getTasksByProjectId service function (line 12 imports, line 51 named export, line 68 default export).
    import getTasksByProjectId from './tasks/getTasksByProjectId.js';
    import getTaskListsByProjectId from './tasks/getTaskListsByProjectId.js';
    import getTaskById from './tasks/getTaskById.js';
    import createTask from './tasks/createTask.js';
    import createSubTask from './tasks/createSubTask.js';
    import updateTask from './tasks/updateTask.js';
    import deleteTask from './tasks/deleteTask.js';
    import getTaskComments from './tasks/getTaskComments.js';
    
    // Comment-related exports
    import createComment from './comments/createComment.js';
    
    // People-related exports
    import getPeople, { PeopleQueryParams } from './people/getPeople.js';
    import getPersonById from './people/getPersonById.js';
    import getProjectPeople from './people/getProjectPeople.js';
    import addPeopleToProject, { AddPeopleToProjectPayload } from './people/addPeopleToProject.js';
    import deletePerson from './people/deletePerson.js';
    import updatePerson from './people/updatePerson.js';
    import getPeopleMetricsPerformance from './people/getPeopleMetricsPerformance.js';
    import getPeopleUtilization from './people/getPeopleUtilization.js';
    import getProjectPerson from './people/getProjectPerson.js';
    
    // Company-related exports
    import createCompany from './companies/createCompany.js';
    import updateCompany from './companies/updateCompany.js';
    import deleteCompany from './companies/deleteCompany.js';
    import getCompanies from './companies/getCompanies.js';
    import getCompanyById from './companies/getCompanyById.js';
    
    // Time-related exports
    import getTime, { GetTimeParams } from './time/getTime.js';
    import getTimezones from './core/getTimezones.js';
    
    // Reporting exports
    import getUserTaskCompletion from './reporting/getUserTaskCompletion.js';
    
    // Re-export all functions
    export { getProjects, getCurrentProject, createProject, CreateProjectData };
    export { getTasks, getTasksByProjectId, getTaskListsByProjectId, getTaskById, createTask, createSubTask, updateTask, deleteTask };
    export { createComment };
    export { getPeople, PeopleQueryParams, getPersonById, getProjectPeople, addPeopleToProject, AddPeopleToProjectPayload, deletePerson, updatePerson, getPeopleMetricsPerformance, getPeopleUtilization, getProjectPerson };
    export { createCompany, updateCompany, deleteCompany, getCompanies, getCompanyById };
    export { getTime, GetTimeParams };
    export { getUserTaskCompletion };
    export { getTimezones };
    
    // Default export with all services
    export default {
      // Projects
      getProjects,
      getCurrentProject,
      createProject,
      
      // Tasks
      getTasks,
      getTasksByProjectId,
  • Service layer function that makes the actual API call to Teamwork's /projects/{projectId}/tasks.json endpoint using the API client. Returns response data.
    import logger from '../../utils/logger.js';
    import { ensureApiClient } from '../core/apiClient.js';
    
    /**
     * Fetches tasks for a specific project from the Teamwork API
     * @param projectId The ID of the project to get tasks for
     * @returns The API response with task data
     */
    export const getTasksByProjectId = async (projectId: string) => {
      try {
        const api = ensureApiClient();
        const response = await api.get(`/projects/${projectId}/tasks.json`);
        return response.data;
      } catch (error: any) {
        logger.error(`Error fetching tasks for project ${projectId}: ${error.message}`);
        throw new Error(`Failed to fetch tasks for project ${projectId}`);
      }
    };
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description implies a read operation ('Get'), but annotations set readOnlyHint to false, creating a contradiction. No additional behavioral traits (e.g., permissions, side effects) are disclosed beyond the implicit read action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no unnecessary words. It is front-loaded and efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simple one-parameter structure and no output schema, the description is mostly complete. However, it lacks details about the return format or pagination, but this is acceptable for a straightforward retrieval.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and the parameter 'projectId' is described in the schema. The description adds no extra meaning beyond the schema, so baseline score of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Get all tasks from a specific project', using a specific verb and resource. Among sibling tools like getTasks and getTasksByTaskListId, this one is uniquely scoped to a project.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like getTasks or getTasksByTaskListId. No exclusion criteria or context is given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Vizioz/Teamwork-MCP'

If you have feedback or need assistance with the MCP directory API, please join our Discord server