linear_transferIssue

Transfer issues between teams in Linear to reorganize work and align responsibilities.

Instructions

Transfer an issue to another team

Input Schema

TableJSON Schema

Name	Required	Description	Default
`issueId`	Yes	ID or identifier of the issue to transfer (e.g., ABC-123)
`teamId`	Yes	ID of the team to transfer the issue to

Implementation Reference

src/tools/handlers/issue-handlers.ts:261-277 (handler)

The handler function that executes the linear_transferIssue tool logic, including argument validation and calling the Linear service to transfer the issue to a new team.

/**
 * Handler for transferring an issue
 */
export function handleTransferIssue(linearService: LinearService) {
  return async (args: unknown) => {
    try {
      if (!isTransferIssueArgs(args)) {
        throw new Error("Invalid arguments for transferIssue");
      }
      
      return await linearService.transferIssue(args.issueId, args.teamId);
    } catch (error) {
      logError("Error transferring issue", error);
      throw error;
    }
  };
}

src/tools/definitions/issue-tools.ts:663-696 (schema)

Defines the input schema (issueId, teamId) and output schema for the linear_transferIssue tool.

export const transferIssueToolDefinition: MCPToolDefinition = {
  name: "linear_transferIssue",
  description: "Transfer an issue to another team",
  input_schema: {
    type: "object",
    properties: {
      issueId: {
        type: "string",
        description: "ID or identifier of the issue to transfer (e.g., ABC-123)",
      },
      teamId: {
        type: "string",
        description: "ID of the team to transfer the issue to",
      },
    },
    required: ["issueId", "teamId"],
  },
  output_schema: {
    type: "object",
    properties: {
      success: { type: "boolean" },
      issue: {
        type: "object",
        properties: {
          id: { type: "string" },
          identifier: { type: "string" },
          title: { type: "string" },
          team: { type: "object" },
          url: { type: "string" }
        }
      }
    }
  }
};

src/tools/handlers/index.ts:51-101 (registration)

Registers the linear_transferIssue tool by mapping the name to the handleTransferIssue handler function within the tool handlers registry.

export function registerToolHandlers(linearService: LinearService) {
  return {
    // User tools
    linear_getViewer: handleGetViewer(linearService),
    linear_getOrganization: handleGetOrganization(linearService),
    linear_getUsers: handleGetUsers(linearService),
    linear_getLabels: handleGetLabels(linearService),

    // Team tools
    linear_getTeams: handleGetTeams(linearService),
    linear_getWorkflowStates: handleGetWorkflowStates(linearService),

    // Project tools
    linear_getProjects: handleGetProjects(linearService),
    linear_createProject: handleCreateProject(linearService),
    
    // Project Management tools
    linear_updateProject: handleUpdateProject(linearService),
    linear_addIssueToProject: handleAddIssueToProject(linearService),
    linear_getProjectIssues: handleGetProjectIssues(linearService),
    
    // Cycle Management tools
    linear_getCycles: handleGetCycles(linearService),
    linear_getActiveCycle: handleGetActiveCycle(linearService),
    linear_addIssueToCycle: handleAddIssueToCycle(linearService),

    // Issue tools
    linear_getIssues: handleGetIssues(linearService),
    linear_getIssueById: handleGetIssueById(linearService),
    linear_searchIssues: handleSearchIssues(linearService),
    linear_createIssue: handleCreateIssue(linearService),
    linear_updateIssue: handleUpdateIssue(linearService),
    linear_createComment: handleCreateComment(linearService),
    linear_addIssueLabel: handleAddIssueLabel(linearService),
    linear_removeIssueLabel: handleRemoveIssueLabel(linearService),
    
    // New Issue Management tools
    linear_assignIssue: handleAssignIssue(linearService),
    linear_subscribeToIssue: handleSubscribeToIssue(linearService),
    linear_convertIssueToSubtask: handleConvertIssueToSubtask(linearService),
    linear_createIssueRelation: handleCreateIssueRelation(linearService),
    linear_archiveIssue: handleArchiveIssue(linearService),
    linear_setIssuePriority: handleSetIssuePriority(linearService),
    linear_transferIssue: handleTransferIssue(linearService),
    linear_duplicateIssue: handleDuplicateIssue(linearService),
    linear_getIssueHistory: handleGetIssueHistory(linearService),
    
    // Comment Management tools
    linear_getComments: handleGetComments(linearService)
  };
}

src/tools/type-guards.ts:350-365 (helper)

Type guard function used to validate the input arguments for the linear_transferIssue tool.

/**
 * Type guard for linear_transferIssue tool arguments
 */
export function isTransferIssueArgs(args: unknown): args is {
  issueId: string;
  teamId: string;
} {
  return (
    typeof args === "object" &&
    args !== null &&
    "issueId" in args &&
    typeof (args as { issueId: string }).issueId === "string" &&
    "teamId" in args &&
    typeof (args as { teamId: string }).teamId === "string"
  );
}

src/tools/definitions/index.ts:47-95 (registration)

Includes the transferIssueToolDefinition in the array of all tool definitions for registration.

export const allToolDefinitions: MCPToolDefinition[] = [
  // User tools
  getViewerToolDefinition,
  getOrganizationToolDefinition,
  getUsersToolDefinition,
  getLabelsToolDefinition,
  
  // Team tools
  getTeamsToolDefinition,
  getWorkflowStatesToolDefinition,
  
  // Project tools
  getProjectsToolDefinition,
  createProjectToolDefinition,
  
  // Project Management tools
  updateProjectToolDefinition,
  addIssueToProjectToolDefinition,
  getProjectIssuesToolDefinition,
  
  // Cycle Management tools
  getCyclesToolDefinition,
  getActiveCycleToolDefinition,
  addIssueToCycleToolDefinition,
  
  // Issue tools
  getIssuesToolDefinition,
  getIssueByIdToolDefinition,
  searchIssuesToolDefinition,
  createIssueToolDefinition,
  updateIssueToolDefinition,
  createCommentToolDefinition,
  addIssueLabelToolDefinition,
  removeIssueLabelToolDefinition,
  
  // New Issue Management tools
  assignIssueToolDefinition,
  subscribeToIssueToolDefinition,
  convertIssueToSubtaskToolDefinition,
  createIssueRelationToolDefinition,
  archiveIssueToolDefinition,
  setIssuePriorityToolDefinition,
  transferIssueToolDefinition,
  duplicateIssueToolDefinition,
  getIssueHistoryToolDefinition,
  
  // Comment Management tools
  getCommentsToolDefinition
];

Linear MCP Server