Skip to main content
Glama

request_planning

Register user requests and plan associated tasks to initiate structured workflows within the MCP TaskManager server.

Instructions

Register a new user request and plan its associated tasks. You must provide 'originalRequest' and 'tasks', and optionally 'splitDetails'.

This tool initiates a new workflow for handling a user's request. The workflow is as follows:

  1. Use 'request_planning' to register a request and its tasks.

  2. After adding tasks, you MUST use 'get_next_task' to retrieve the first task. A progress table will be displayed.

  3. Use 'get_next_task' to retrieve the next uncompleted task.

  4. IMPORTANT: After marking a task as done, the assistant MUST NOT proceed to another task without the user's approval. The user must explicitly approve the completed task using 'approve_task_completion'. A progress table will be displayed before each approval request.

  5. Once a task is approved, you can proceed to 'get_next_task' again to fetch the next pending task.

  6. Repeat this cycle until all tasks are done.

  7. After all tasks are completed (and approved), 'get_next_task' will indicate that all tasks are done and that the request awaits approval for full completion.

  8. The user must then approve the entire request's completion using 'approve_request_completion'. If the user does not approve and wants more tasks, you can again use 'request_planning' to add new tasks and continue the cycle.

The critical point is to always wait for user approval after completing each task and after all tasks are done, wait for request completion approval. Do not proceed automatically.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
originalRequestYes
splitDetailsNo
tasksYes

Implementation Reference

  • The core handler function for the 'request_planning' tool. It increments counters to generate unique IDs for the request and tasks, constructs Task objects from input, adds the new RequestEntry to the data store, saves to persistent storage, and returns the requestId and a progress table message.
    public async requestPlanning(
      originalRequest: string,
      tasks: { title: string; description: string }[],
      splitDetails?: string
    ) {
      this.requestCounter++;
      const requestId = `req-${this.requestCounter}`;
    
      const taskEntries: Task[] = tasks.map((t) => {
        this.taskCounter++;
        return {
          id: `task-${this.taskCounter}`,
          title: t.title,
          description: t.description,
          done: false,
          approved: false,
          completedDetails: "",
        };
      });
    
      this.data.requests.push({
        requestId,
        originalRequest,
        splitDetails: splitDetails || "",
        tasks: taskEntries,
        completed: false,
      });
    
      await this.saveTasks();
    
      return {
        requestId,
        message: "Request registered successfully.\n" + this.formatTaskProgressTable(requestId),
      };
    }
  • Zod schema defining the input structure for the request_planning tool: originalRequest, optional splitDetails, and array of tasks with title and description.
    const RequestPlanningSchema = z.object({
      originalRequest: z.string(),
      splitDetails: z.string().optional(),
      tasks: z.array(
        z.object({
          title: z.string(),
          description: z.string(),
        })
      ),
    });
  • index.ts:145-149 (registration)
    Registers the request_planning tool within the listTools() method of the TaskManagerServer class, specifying its name, description, and input schema.
    {
      name: "request_planning",
      description: "Register a new user request and plan its associated tasks.",
      inputSchema: RequestPlanningSchema,
    },
Behavior4/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: it initiates a workflow, requires user approval after each task and at the end, and interacts with other tools in a specific sequence. It also implies this is a write operation (registering and planning), though it doesn't detail error handling or permissions. The description adds substantial context beyond what's in the schema, making it highly transparent.

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

Conciseness3/5

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

The description is appropriately front-loaded with the tool's purpose and required parameters, but it includes extensive workflow instructions that may be overly detailed for a tool description. While these guidelines are helpful, they could be more concise. The text is structured with numbered steps, but some sentences are verbose, such as the repeated emphasis on user approval, which slightly reduces efficiency.

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

Completeness5/5

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

Given the complexity of the tool (initiating a multi-step workflow with user interactions) and the lack of annotations and output schema, the description is highly complete. It covers the tool's role in the workflow, parameter requirements, behavioral constraints (e.g., approval cycles), and interactions with sibling tools. This provides sufficient context for an AI agent to use the tool correctly despite the missing structured data.

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

Parameters4/5

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

The schema description coverage is 0%, so the description must compensate. It specifies that 'originalRequest' and 'tasks' are required, and 'splitDetails' is optional, adding meaning beyond the schema's basic types. It explains that 'tasks' is an array of objects with 'title' and 'description', clarifying the structure. However, it doesn't detail the format or constraints of 'originalRequest' or 'splitDetails', leaving some ambiguity.

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

Purpose4/5

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

The description clearly states the tool's purpose: 'Register a new user request and plan its associated tasks.' It specifies the verb ('register' and 'plan') and resource ('user request' and 'tasks'), making the action explicit. However, it doesn't explicitly differentiate from sibling tools like 'add_tasks_to_request' or 'list_requests', which slightly reduces clarity.

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

Usage Guidelines5/5

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

The description provides explicit, detailed guidance on when to use this tool versus alternatives. It outlines a complete workflow starting with 'request_planning', followed by 'get_next_task', 'approve_task_completion', and 'approve_request_completion', and explicitly states not to proceed automatically without user approval. It also mentions that if the user wants more tasks after disapproval, 'request_planning' can be used again, distinguishing it from other tools in the cycle.

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/Rudra-ravi/mcp-taskmanager'

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