Skip to main content
Glama

create_task

Create a new Dart task with title, description, priority, tags, size, assignees, and subscribers for AI-assisted task management.

Instructions

Create a new Dart task

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
titleYesTitle of the task
descriptionYesDescription of the task
priorityNoPriority of the task
tagsNoTags for the task
sizeNoSize/complexity of the task (1-5)
assignee_duidsNoList of assignee DUIDs
subscriber_duidsNoList of subscriber DUIDs

Implementation Reference

  • The handler for 'create_task' tool call. It generates embedded Python code to create a TaskCreate object, wraps it in an Operation, executes a transaction via the Dart client, and returns the result.
                    case 'create_task': {
                        console.error('[Debug] Handling create_task request');
                        const pythonCode = `    # Parse optional parameters from JSON
    tags_json = '''${JSON.stringify(args.tags || [])}'''
    assignee_duids_json = '''${JSON.stringify(args.assignee_duids || [])}'''
    subscriber_duids_json = '''${JSON.stringify(args.subscriber_duids || [])}'''
    
    # Convert JSON strings to Python objects
    tags = json.loads(tags_json) if tags_json.strip() != '[]' else []
    assignee_duids = json.loads(assignee_duids_json) if assignee_duids_json.strip() != '[]' else []
    subscriber_duids = json.loads(subscriber_duids_json) if subscriber_duids_json.strip() != '[]' else []
    
    print("[Debug] Creating task object", file=sys.stderr)
    
    # Create the task
    task = TaskCreate(
        source_type=TaskSourceType.CLI,
        duid=_make_duid(),  # Generate a new DUID for the task
        dartboard_duid=dartboard_duid,  # Set the dartboard DUID separately
        title='''${args.title.replace(/'/g, "\\'")}''',
        description='''${args.description.replace(/'/g, "\\'")}''',
        priority="${args.priority || 'Medium'}",
        size=${args.size || 1}
    )
    
    # Add optional parameters if they exist
    if tags:
        print("[Debug] Adding tags:", tags, file=sys.stderr)
        task.tag_duids = tags
    if assignee_duids:
        print("[Debug] Adding assignees:", assignee_duids, file=sys.stderr)
        task.assignee_duids = assignee_duids
    if subscriber_duids:
        print("[Debug] Adding subscribers:", subscriber_duids, file=sys.stderr)
        task.subscriber_duids = subscriber_duids
    
    print("[Debug] Task object created:", task, file=sys.stderr)
    
    print("[Debug] Creating operation", file=sys.stderr)
    task_op = Operation(
        model=OperationModelKind.TASK,
        kind=OperationKind.CREATE,
        data=task
    )
    print("[Debug] Operation created:", task_op, file=sys.stderr)
    
    print("[Debug] Executing transaction", file=sys.stderr)
    response = client.transact([task_op], TransactionKind.TASK_CREATE)
    print("[Debug] Transaction completed", file=sys.stderr)
    
    if response.results and response.results[0].success:
        task = response.results[0].models.tasks[0]
        print(f"Task created successfully with DUID: {task.duid}")
        print(f"[Debug] Task DUID: {task.duid}", file=sys.stderr)
    else:
        print("[Debug] Task creation failed", file=sys.stderr)
        if response.results:
            print(f"[Debug] Result: {response.results[0]}", file=sys.stderr)
        sys.exit(1)`;
                        
                        // Add proper indentation to the Python code
                        const command = pythonCode.split('\n').map(line => line.length > 0 ? '    ' + line : line).join('\n');
    
                        console.error('[Debug] Running Python command for task creation');
                        const output = await this.runDartCommand(command);
                        console.error('[Debug] Task creation output:', output);
                        const response = {
                            content: [{
                                type: 'text',
                                text: output,
                            }],
                        };
                        console.error('[Debug] Sending task creation response:', JSON.stringify(response, null, 2));
                        return response;
                    }
  • Input schema for the create_task tool, specifying required title and description, and optional fields like priority, tags, size, assignees, and subscribers.
        name: 'create_task',
        description: 'Create a new Dart task',
        inputSchema: {
            type: 'object',
            properties: {
                title: {
                    type: 'string',
                    description: 'Title of the task',
                },
                description: {
                    type: 'string',
                    description: 'Description of the task',
                },
                priority: {
                    type: 'string',
                    description: 'Priority of the task',
                    enum: ['Low', 'Medium', 'High', 'Critical'],
                },
                tags: {
                    type: 'array',
                    items: {
                        type: 'string',
                    },
                    description: 'Tags for the task',
                },
                size: {
                    type: 'number',
                    description: 'Size/complexity of the task (1-5)',
                    minimum: 1,
                    maximum: 5,
                },
                assignee_duids: {
                    type: 'array',
                    items: {
                        type: 'string',
                    },
                    description: 'List of assignee DUIDs',
                },
                subscriber_duids: {
                    type: 'array',
                    items: {
                        type: 'string',
                    },
                    description: 'List of subscriber DUIDs',
                }
            },
            required: ['title', 'description'],
        },
    },
  • src/index.ts:230-513 (registration)
    The ListTools request handler registers the create_task tool by including it in the static tools array returned to clients.
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
        console.error('[Debug] Handling listTools request');
        const tools = [
            {
                name: 'get_default_status',
                description: 'Get the default status DUIDs',
                inputSchema: {
                    type: 'object',
                    properties: {},
                    required: [],
                },
            },
            {
                name: 'get_default_space',
                description: 'Get the default space DUID',
                inputSchema: {
                    type: 'object',
                    properties: {},
                    required: [],
                },
            },
            {
                name: 'create_task',
                description: 'Create a new Dart task',
                inputSchema: {
                    type: 'object',
                    properties: {
                        title: {
                            type: 'string',
                            description: 'Title of the task',
                        },
                        description: {
                            type: 'string',
                            description: 'Description of the task',
                        },
                        priority: {
                            type: 'string',
                            description: 'Priority of the task',
                            enum: ['Low', 'Medium', 'High', 'Critical'],
                        },
                        tags: {
                            type: 'array',
                            items: {
                                type: 'string',
                            },
                            description: 'Tags for the task',
                        },
                        size: {
                            type: 'number',
                            description: 'Size/complexity of the task (1-5)',
                            minimum: 1,
                            maximum: 5,
                        },
                        assignee_duids: {
                            type: 'array',
                            items: {
                                type: 'string',
                            },
                            description: 'List of assignee DUIDs',
                        },
                        subscriber_duids: {
                            type: 'array',
                            items: {
                                type: 'string',
                            },
                            description: 'List of subscriber DUIDs',
                        }
                    },
                    required: ['title', 'description'],
                },
            },
            {
                name: 'update_task',
                description: 'Update an existing task',
                inputSchema: {
                    type: 'object',
                    properties: {
                        duid: {
                            type: 'string',
                            description: 'DUID of the task to update',
                        },
                        status_duid: {
                            type: 'string',
                            description: 'New status DUID',
                        },
                        title: {
                            type: 'string',
                            description: 'New title for the task',
                        },
                        description: {
                            type: 'string',
                            description: 'New description for the task',
                        },
                        priority: {
                            type: 'string',
                            description: 'New priority for the task',
                            enum: ['Low', 'Medium', 'High', 'Critical'],
                        }
                    },
                    required: ['duid'],
                },
            },
            {
                name: 'get_dartboards',
                description: 'Get available dartboards',
                inputSchema: {
                    type: 'object',
                    properties: {
                        space_duid: {
                            type: 'string',
                            description: 'Space DUID to get dartboards from',
                        }
                    },
                    required: ['space_duid'],
                },
            },
            {
                name: 'get_folders',
                description: 'Get available folders',
                inputSchema: {
                    type: 'object',
                    properties: {
                        space_duid: {
                            type: 'string',
                            description: 'Space DUID to get folders from',
                        }
                    },
                    required: ['space_duid'],
                },
            },
            {
                name: 'create_folder',
                description: 'Create a new folder in a space',
                inputSchema: {
                    type: 'object',
                    properties: {
                        space_duid: {
                            type: 'string',
                            description: 'Space DUID to create the folder in',
                        },
                        title: {
                            type: 'string',
                            description: 'Title of the folder',
                        },
                        description: {
                            type: 'string',
                            description: 'Description of the folder',
                        },
                        kind: {
                            type: 'string',
                            description: 'Kind of folder',
                            enum: ['Default', 'Reports', 'Other'],
                            default: 'Default'
                        }
                    },
                    required: ['space_duid', 'title'],
                },
            },
            {
                name: 'create_doc',
                description: 'Create a new document or report',
                inputSchema: {
                    type: 'object',
                    properties: {
                        folder_duid: {
                            type: 'string',
                            description: 'Folder DUID to create the document in',
                        },
                        title: {
                            type: 'string',
                            description: 'Title of the document',
                        },
                        text: {
                            type: 'string',
                            description: 'Content of the document',
                        },
                        text_markdown: {
                            type: 'string',
                            description: 'Markdown content of the document',
                        },
                        report_kind: {
                            type: 'string',
                            description: 'Kind of report (if creating a report)',
                            enum: ['Changelog', 'Standup'],
                        },
                        editor_duids: {
                            type: 'array',
                            items: {
                                type: 'string',
                            },
                            description: 'List of editor DUIDs',
                        },
                        subscriber_duids: {
                            type: 'array',
                            items: {
                                type: 'string',
                            },
                            description: 'List of subscriber DUIDs',
                        }
                    },
                    required: ['folder_duid', 'title'],
                },
            },
            {
                name: 'create_space',
                description: 'Create a new space',
                inputSchema: {
                    type: 'object',
                    properties: {
                        title: {
                            type: 'string',
                            description: 'Title of the space'
                        },
                        description: {
                            type: 'string',
                            description: 'Description of the space'
                        },
                        abrev: {
                            type: 'string',
                            description: 'Short abbreviation for the space'
                        },
                        accessible_by_team: {
                            type: 'boolean',
                            description: 'Whether the space is accessible by the whole team',
                            default: true
                        },
                        accessible_by_user_duids: {
                            type: 'array',
                            items: {
                                type: 'string'
                            },
                            description: 'List of user DUIDs who can access the space'
                        },
                        icon_kind: {
                            type: 'string',
                            enum: ['None', 'Icon', 'Emoji'],
                            description: 'Kind of icon to use',
                            default: 'None'
                        },
                        icon_name_or_emoji: {
                            type: 'string',
                            description: 'Icon name or emoji character'
                        },
                        color_hex: {
                            type: 'string',
                            description: 'Color in hex format (e.g. #FF0000)'
                        },
                        sprint_mode: {
                            type: 'string',
                            enum: ['None', 'ANBA'],
                            description: 'Sprint mode for the space',
                            default: 'None'
                        },
                        sprint_replicate_on_rollover: {
                            type: 'boolean',
                            description: 'Whether to replicate sprints on rollover',
                            default: false
                        },
                        sprint_name_fmt: {
                            type: 'string',
                            description: 'Sprint name format'
                        }
                    },
                    required: ['title']
                }
            },
            {
                name: 'delete_space',
                description: 'Delete a space and all its contents',
                inputSchema: {
                    type: 'object',
                    properties: {
                        space_duid: {
                            type: 'string',
                            description: 'DUID of the space to delete'
                        }
                    },
                    required: ['space_duid']
                }
            }
        ];
        console.error('[Debug] Sending tools response:', JSON.stringify(tools, null, 2));
        return { tools };
    });
  • Helper method runDartCommand used by create_task (and other tools) to execute dynamically generated Python code that interacts with the Dart API via child_process.spawn.
        async runDartCommand(args) {
            return new Promise((resolve, reject) => {
                // Use pyenv Python
                const pythonPath = '/Users/speed/.pyenv/shims/python';
                console.error('[Debug] Running Python command with:', pythonPath);
                
                const command = `import sys
    import os
    import traceback
    import json
    from dart import Dart, Operation, OperationKind, OperationModelKind, TaskCreate, TaskUpdate, TransactionKind, TaskSourceType, SpaceCreate
    from dart.generated.types import UNSET
    from dart.dart import _Session, UserBundle, _make_duid
    from dart.generated.models.icon_kind import IconKind
    from dart.generated.models.sprint_mode import SprintMode
    from dart.generated.models.validation_error_response import ValidationErrorResponse
    
    def initialize():
        print("[Debug] Starting Python execution", file=sys.stderr)
        print("[Debug] Current directory:", os.getcwd(), file=sys.stderr)
        print("[Debug] PYTHONPATH:", os.environ.get('PYTHONPATH'), file=sys.stderr)
        print("[Debug] DART_TOKEN:", os.environ.get('DART_TOKEN'), file=sys.stderr)
        
        session = _Session()
        print("[Debug] Session created", file=sys.stderr)
        bundle = UserBundle(session)
        print("[Debug] UserBundle created", file=sys.stderr)
        dartboard_duid = bundle.default_dartboard["duid"]
        print(f"[Debug] Got dartboard DUID: {dartboard_duid}", file=sys.stderr)
        client = Dart()
        print("[Debug] Dart client created", file=sys.stderr)
        
        return client, bundle, dartboard_duid
    
    def run_command(client, bundle, dartboard_duid):
        ${args}
    
    def main():
        client, bundle, dartboard_duid = initialize()
        run_command(client, bundle, dartboard_duid)
    
    try:
        main()
    except Exception as e:
        print(f"Error: {str(e)}", file=sys.stderr)
        traceback.print_exc(file=sys.stderr)
        sys.exit(1)`;
                
                console.error('[Debug] Python command:', command);
    
                // Create a clean environment without virtual env variables
                const env = { ...process.env };
                delete env.VIRTUAL_ENV;
                delete env.CONDA_PREFIX;
                delete env.CONDA_DEFAULT_ENV;
                delete env.CONDA_PYTHON_EXE;
    
                const childProcess = spawn(pythonPath, ['-c', command], {
                    env: {
                        ...env,
                        PYTHONUNBUFFERED: '1',
                        PYTHONPATH: process.env.PYTHONPATH || process.cwd(),
                        DART_TOKEN: process.env.DART_TOKEN,
                    },
                    stdio: ['pipe', 'pipe', 'pipe'],
                });
    
                let output = '';
                let errorOutput = '';
    
                childProcess.stdout?.on('data', (data) => {
                    const str = data.toString();
                    console.error('[Debug] Python stdout:', str);
                    output += str;
                });
    
                childProcess.stderr?.on('data', (data) => {
                    const str = data.toString();
                    console.error('[Debug] Python stderr:', str);
                    errorOutput += str;
                });
    
                childProcess.on('error', (error) => {
                    console.error('[Debug] Python process error:', error);
                    reject(new Error(`Failed to start Python process: ${error.message}`));
                });
    
                // Add timeout
                const timeout = setTimeout(() => {
                    console.error('[Debug] Python command timed out');
                    childProcess.kill();
                    reject(new Error('Command timed out'));
                }, 30000); // 30 second timeout
    
                childProcess.on('close', (code) => {
                    clearTimeout(timeout);
                    console.error(`[Debug] Python process exited with code ${code}`);
                    if (code === 0) {
                        resolve(output.trim());
                    } else {
                        reject(new Error(errorOutput || `Command failed with exit code ${code}`));
                    }
                });
            });
        }
Behavior2/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. While 'Create' implies a write/mutation operation, the description doesn't address important behavioral aspects: whether this requires specific permissions, what happens on success/failure, whether the creation is immediate or queued, or what the response contains. For a mutation tool with zero annotation coverage, this is insufficient.

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 maximally concise - a single 4-word sentence that communicates the core purpose without any wasted words. It's front-loaded with the essential information and earns its place efficiently.

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

Completeness2/5

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

For a mutation tool with 7 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what a 'Dart task' is, what happens after creation, whether there are side effects, or what the agent should expect as a result. The agent would need to guess about important behavioral aspects of this creation operation.

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?

The schema description coverage is 100%, with all 7 parameters well-documented in the schema itself. The description adds no additional parameter information beyond what's already in the structured schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

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 verb ('Create') and resource ('Dart task'), making the purpose immediately understandable. However, it doesn't differentiate this from sibling tools like 'create_doc', 'create_folder', or 'create_space' - all of which create different types of resources in the same system.

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 about when to use this tool versus alternatives. There's no mention of prerequisites, when to choose this over other creation tools, or any context about what constitutes a 'Dart task' versus other resource types. The agent must infer usage from the tool name alone.

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/jmanhype/dart-mcp-server'

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