todoist_subtask_create

Instructions

Implementation Reference

• src/tools/subtask-tools.ts:1-49 (schema)

  Tool definition/schema for todoist_subtask_create - defines name, description, and inputSchema with all parameters (parent_task_id, parent_task_name, content, etc.)

  // Subtask management tools for hierarchical task operations
  import { Tool } from "@modelcontextprotocol/sdk/types.js";
  
  export const CREATE_SUBTASK_TOOL: Tool = {
    name: "todoist_subtask_create",
    description: "Create a new subtask under a parent task in Todoist",
    inputSchema: {
      type: "object",
      properties: {
        parent_task_id: {
          type: "string",
          description: "ID of the parent task (provide this OR parent_task_name)",
        },
        parent_task_name: {
          type: "string",
          description:
            "Name/content of the parent task (provide this OR parent_task_id)",
        },
        content: {
          type: "string",
          description: "Content of the subtask",
        },
        description: {
          type: "string",
          description: "Description of the subtask (optional)",
        },
        due_string: {
          type: "string",
          description:
            "Human-readable due date string (e.g., 'tomorrow', 'next Monday')",
        },
        priority: {
          type: "number",
          description: "Priority level 1 (highest) to 4 (lowest)",
          minimum: 1,
          maximum: 4,
        },
        labels: {
          type: "array",
          items: { type: "string" },
          description: "Array of label names to apply to the subtask",
        },
        deadline_date: {
          type: "string",
          description: "Deadline date in YYYY-MM-DD format",
        },
      },
      required: ["content"],
    },

• src/handlers/subtask-handlers.ts:100-145 (handler)

  Core handler function handleCreateSubtask - validates inputs, finds parent task via findTask(), constructs TaskCreationData, calls todoistClient.addTask(), clears cache, and returns {subtask, parent}

  export async function handleCreateSubtask(
    todoistClient: TodoistApi,
    args: CreateSubtaskArgs
  ): Promise<{ subtask: TodoistTask; parent: TodoistTask }> {
    try {
      // Validate required fields
      validateTaskContent(args.content);
  
      // Find parent task
      const parent = await findTask(todoistClient, {
        task_id: args.parent_task_id,
        task_name: args.parent_task_name,
      });
  
      // Validate optional fields
      if (args.priority !== undefined) {
        validatePriority(args.priority);
      }
      if (args.deadline_date) {
        validateDateString(args.deadline_date, "deadline");
      }
  
      // Create subtask with parentId
      const subtaskData: TaskCreationData = {
        content: args.content,
        parentId: parent.id,
        projectId: parent.projectId,
      };
  
      if (args.description) subtaskData.description = args.description;
      if (args.due_string) subtaskData.dueString = args.due_string;
      const apiPriority = toApiPriority(args.priority);
      if (apiPriority !== undefined) subtaskData.priority = apiPriority;
      if (args.labels) subtaskData.labels = args.labels;
      if (args.deadline_date) subtaskData.deadline = { date: args.deadline_date };
  
      const subtask = (await todoistClient.addTask(subtaskData)) as TodoistTask;
  
      // Clear cache
      taskCache.clear();
  
      return { subtask, parent };
    } catch (error) {
      throw ErrorHandler.handleAPIError("createSubtask", error);
    }
  }

• src/types/subtask-types.ts:10-19 (schema)

  TypeScript interface CreateSubtaskArgs defining the shape of input arguments (parent_task_id?, parent_task_name?, content, description?, due_string?, priority?, labels?, deadline_date?)

  export interface CreateSubtaskArgs {
    parent_task_id?: string;
    parent_task_name?: string;
    content: string;
    description?: string;
    due_string?: string;
    priority?: number;
    labels?: string[];
    deadline_date?: string;
  }

• src/router/legacy-router.ts:417-423 (registration)

  Route registration in legacy-router.ts - dispatches 'todoist_subtask_create' to handleCreateSubtask via type guard and returns formatted result string

  case "todoist_subtask_create": {
    if (!isCreateSubtaskArgs(args)) {
      throw new Error("Invalid arguments for todoist_subtask_create");
    }
    const subtaskResult = await handleCreateSubtask(client, args);
    return `Created subtask "${subtaskResult.subtask.content}" (ID: ${subtaskResult.subtask.id}) under parent task "${subtaskResult.parent.content}" (ID: ${subtaskResult.parent.id})`;
  }

• src/type-guards/subtask-guards.ts:15-28 (helper)

  Type guard isCreateSubtaskArgs - validates runtime arguments (content must be string, parent_task_id or parent_task_name must be provided)

  export function isCreateSubtaskArgs(args: unknown): args is CreateSubtaskArgs {
    if (typeof args !== "object" || args === null) return false;
  
    const obj = args as Record<string, unknown>;
    return (
      "content" in obj &&
      typeof obj.content === "string" &&
      (obj.parent_task_id === undefined ||
        typeof obj.parent_task_id === "string") &&
      (obj.parent_task_name === undefined ||
        typeof obj.parent_task_name === "string") &&
      (obj.parent_task_id !== undefined || obj.parent_task_name !== undefined)
    );
  }