ServiceNow MCP Server

Instructions

Implementation Reference

• src/servicenow_mcp/tools/script_include_tools.py:333-429 (handler)

  Core handler function implementing the logic to update a ServiceNow script include by first retrieving it, building the update payload, and performing a PATCH request to the API.

  def update_script_include(
      config: ServerConfig,
      auth_manager: AuthManager,
      params: UpdateScriptIncludeParams,
  ) -> ScriptIncludeResponse:
      """Update an existing script include in ServiceNow.
      
      Args:
          config: The server configuration.
          auth_manager: The authentication manager.
          params: The parameters for the request.
          
      Returns:
          A response indicating the result of the operation.
      """
      # First, get the script include to update
      get_params = GetScriptIncludeParams(script_include_id=params.script_include_id)
      get_result = get_script_include(config, auth_manager, get_params)
      
      if not get_result["success"]:
          return ScriptIncludeResponse(
              success=False,
              message=get_result["message"],
          )
          
      script_include = get_result["script_include"]
      sys_id = script_include["sys_id"]
      
      # Build the URL
      url = f"{config.instance_url}/api/now/table/sys_script_include/{sys_id}"
      
      # Build the request body
      body = {}
      
      if params.script is not None:
          body["script"] = params.script
          
      if params.description is not None:
          body["description"] = params.description
          
      if params.api_name is not None:
          body["api_name"] = params.api_name
          
      if params.client_callable is not None:
          body["client_callable"] = str(params.client_callable).lower()
          
      if params.active is not None:
          body["active"] = str(params.active).lower()
          
      if params.access is not None:
          body["access"] = params.access
          
      # If no fields to update, return success
      if not body:
          return ScriptIncludeResponse(
              success=True,
              message=f"No changes to update for script include: {script_include['name']}",
              script_include_id=sys_id,
              script_include_name=script_include["name"],
          )
          
      # Make the request
      headers = auth_manager.get_headers()
      
      try:
          response = requests.patch(
              url,
              json=body,
              headers=headers,
              timeout=30,
          )
          response.raise_for_status()
          
          # Parse the response
          data = response.json()
          
          if "result" not in data:
              return ScriptIncludeResponse(
                  success=False,
                  message=f"Failed to update script include: {script_include['name']}",
              )
              
          result = data["result"]
          
          return ScriptIncludeResponse(
              success=True,
              message=f"Updated script include: {result.get('name')}",
              script_include_id=result.get("sys_id"),
              script_include_name=result.get("name"),
          )
          
      except Exception as e:
          logger.error(f"Error updating script include: {e}")
          return ScriptIncludeResponse(
              success=False,
              message=f"Error updating script include: {str(e)}",
          )

• src/servicenow_mcp/tools/script_include_tools.py:47-57 (schema)

  Pydantic BaseModel defining the input parameters and validation for the update_script_include tool.

  class UpdateScriptIncludeParams(BaseModel):
      """Parameters for updating a script include."""
      
      script_include_id: str = Field(..., description="Script include ID or name")
      script: Optional[str] = Field(None, description="Script content")
      description: Optional[str] = Field(None, description="Description of the script include")
      api_name: Optional[str] = Field(None, description="API name of the script include")
      client_callable: Optional[bool] = Field(None, description="Whether the script include is client callable")
      active: Optional[bool] = Field(None, description="Whether the script include is active")
      access: Optional[str] = Field(None, description="Access level of the script include")

• src/servicenow_mcp/utils/tool_utils.py:703-709 (registration)

  Tool registration entry in get_tool_definitions() mapping the tool name to its handler function alias, input schema, output type, description, and serialization method.

  "update_script_include": (
      update_script_include_tool,
      UpdateScriptIncludeParams,
      ScriptIncludeResponse,  # Expects Pydantic model
      "Update an existing script include in ServiceNow",
      "raw_pydantic",  # Tool returns Pydantic model
  ),

• src/servicenow_mcp/tools/script_include_tools.py:65-72 (schema)

  Pydantic BaseModel defining the output response structure for script include operations, including update_script_include.

  class ScriptIncludeResponse(BaseModel):
      """Response from script include operations."""
      
      success: bool = Field(..., description="Whether the operation was successful")
      message: str = Field(..., description="Message describing the result")
      script_include_id: Optional[str] = Field(None, description="ID of the affected script include")
      script_include_name: Optional[str] = Field(None, description="Name of the affected script include")

• src/servicenow_mcp/utils/tool_utils.py:203-205 (helper)

  Import and alias of the handler function used in tool registration.

  from servicenow_mcp.tools.script_include_tools import (
      update_script_include as update_script_include_tool,
  )