get_jira_transitions

Instructions

Implementation Reference

• src/mcp_server_jira/server.py:955-980 (handler)

  The primary handler function implementing the get_jira_transitions tool logic. It uses the JiraV3APIClient to fetch transitions and converts them to JiraTransitionResult models.

  async def get_jira_transitions(self, issue_key: str) -> List[JiraTransitionResult]:
      """Get available transitions for an issue using v3 REST API"""
      logger.info("Starting get_jira_transitions...")
  
      try:
          # Use v3 API client
          v3_client = self._get_v3_api_client()
          response_data = await v3_client.get_transitions(issue_id_or_key=issue_key)
  
          # Extract transitions from response
          transitions = response_data.get("transitions", [])
  
          # Convert to JiraTransitionResult objects maintaining compatibility
          results = [
              JiraTransitionResult(id=transition["id"], name=transition["name"])
              for transition in transitions
          ]
  
          logger.info(f"Found {len(results)} transitions for issue {issue_key}")
          return results
  
      except Exception as e:
          error_msg = f"Failed to get transitions for {issue_key}: {type(e).__name__}: {str(e)}"
          logger.error(error_msg, exc_info=True)
          print(error_msg)
          raise ValueError(error_msg)

• src/mcp_server_jira/server.py:1472-1479 (registration)

  Registration of the tool handler in the MCP server's call_tool method. This match statement dispatches calls to 'get_jira_transitions' to the JiraServer.get_jira_transitions method.

  case JiraTools.GET_TRANSITIONS.value:
      logger.info("About to AWAIT jira_server.get_jira_transitions...")
      issue_key = arguments.get("issue_key")
      if not issue_key:
          raise ValueError("Missing required argument: issue_key")
      result = await jira_server.get_jira_transitions(issue_key)
      logger.info("COMPLETED await jira_server.get_jira_transitions.")

• src/mcp_server_jira/server.py:1287-1299 (schema)

  The input schema definition for the get_jira_transitions tool, registered in the server's list_tools method.

  Tool(
      name=JiraTools.GET_TRANSITIONS.value,
      description="Get available workflow transitions for a Jira issue",
      inputSchema={
          "type": "object",
          "properties": {
              "issue_key": {
                  "type": "string",
                  "description": "The issue key (e.g., PROJECT-123)",
              }
          },
          "required": ["issue_key"],
      },

• src/mcp_server_jira/jira_v3_api.py:244-292 (helper)

  Supporting helper method in JiraV3APIClient that performs the actual HTTP request to Jira's /rest/api/3/issue/{issue}/transitions endpoint to retrieve available transitions.

  async def get_transitions(
      self,
      issue_id_or_key: str,
      expand: Optional[str] = None,
      transition_id: Optional[str] = None,
      skip_remote_only_condition: Optional[bool] = None,
      include_unavailable_transitions: Optional[bool] = None,
      sort_by_ops_bar_and_status: Optional[bool] = None,
  ) -> Dict[str, Any]:
      """
      Get available transitions for an issue using the v3 REST API.
  
      Returns either all transitions or a transition that can be performed by the user
      on an issue, based on the issue's status.
  
      Args:
          issue_id_or_key: Issue ID or key (required)
          expand: Expand additional transition fields in response
          transition_id: Get only the transition matching this ID
          skip_remote_only_condition: Skip remote-only conditions check
          include_unavailable_transitions: Include transitions that can't be performed
          sort_by_ops_bar_and_status: Sort transitions by operations bar and status
  
      Returns:
          Dictionary containing the transitions response with transition details
  
      Raises:
          ValueError: If the API request fails
      """
      if not issue_id_or_key:
          raise ValueError("issue_id_or_key is required")
  
      params = {
          "expand": expand,
          "transitionId": transition_id,
          "skipRemoteOnlyCondition": skip_remote_only_condition,
          "includeUnavailableTransitions": include_unavailable_transitions,
          "sortByOpsBarAndStatus": sort_by_ops_bar_and_status,
      }
  
      params = {k: v for k, v in params.items() if v is not None}
  
      endpoint = f"/issue/{issue_id_or_key}/transitions"
      logger.debug(
          f"Fetching transitions with v3 API endpoint: {endpoint} with params: {params}"
      )
      response_data = await self._make_v3_api_request("GET", endpoint, params=params)
      logger.debug(f"Transitions API response: {json.dumps(response_data, indent=2)}")
      return response_data

• src/mcp_server_jira/server.py:103-106 (schema)

  Pydantic model used for output validation and serialization of individual transition results (id and name).

  class JiraTransitionResult(BaseModel):
      id: str
      name: str